TTask

class TTask : public TNamed

    public:

                      TTask()
                      TTask(const char* name, const char* title)
                      TTask(const TTask& task)
              virtual ~TTask()
         virtual void Abort()
         virtual void Add(TTask* task)
         virtual void Browse(TBrowser* b)
       static TClass* Class()
         virtual void CleanTasks()
         virtual void Clear(Option_t* option = "")
         virtual void Continue()
         virtual void Exec(Option_t* option)
         virtual void ExecuteTask(Option_t* option = "0")
         virtual void ExecuteTasks(Option_t* option)
                Int_t GetBreakin() const
                Int_t GetBreakout() const
               TList* GetListOfTasks() const
      virtual TClass* IsA() const
               Bool_t IsActive() const
       virtual Bool_t IsFolder() const
         virtual void ls(Option_t* option = "*") const
               TTask& operator=(const TTask&)
                 void SetActive(Bool_t active = kTRUE)
                 void SetBreakin(Int_t breakin = 1)
                 void SetBreakout(Int_t breakout = 1)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

             TList* fTasks        List of Tasks
            TString fOption       Option specified in ExecuteTask
              Int_t fBreakin      =1 if a break point set at task extry
              Int_t fBreakout     =1 if a break point set at task exit
             Bool_t fHasExecuted  True if task has executed
             Bool_t fActive       true if task is active
      static TTask* fgBeginTask   pointer to task initiator
      static TTask* fgBreakPoint  pointer to current break point

Class Description

 TTask is a base class that can be used to build a complex tree of Tasks.
 Each TTask derived class may contain other TTasks that can be executed
 recursively, such that a complex program can be dynamically built and executed
 by invoking the services of the top level Task or one of its subtasks.

 Use the TTask::Add function to add a subtask to an existing TTask.
 To execute a TTask, one calls the ExecuteTask function. ExecuteTask will
 call recursively:
     - the TTask::Exec function of the derived class
     - TTask::ExecuteTasks to execute for each task the list of its subtasks.
 If the top level task (see example below) is added to the list of Root
 browsable objects, the tree of tasks can be visualized by the Root browser.
 The browser can be used to start a task, set break points at the beginning
 of a task or when the task has completed. At a breakpoint, data structures
 generated by the execution up this point may be inspected asyncronously
 and then the execution can be resumed by selecting the "Continue" function
 of a task.

 A Task may be active or inactive (controlled by TTask::SetActive).
 When a task is not active, its sub tasks are not executed.

 A TTask tree may be made persistent, saving the status of all the tasks.

 The picture in the Root browser below has been generated by executing
 the following script:

{ //------------------script tasks.C---------------------------
   TTask *aliroot  = new TTask("aliroot","ALICE reconstruction main task");
   TTask *geominit = new TTask("geomInit","Initialize ALICE geometry");
   TTask *matinit  = new TTask("matInit","Initialize ALICE materials");
   TTask *physinit = new TTask("physInit","Initialize Physics processes");
   TTask *tracker  = new TTask("tracker","Track reconstruction manager");
   TTask *tpcrec   = new TTask("tpcrec","TPC reconstruction");
   TTask *itsrec   = new TTask("itsrec","ITS reconstruction");
   TTask *muonrec  = new TTask("muonRec","Muon Reconstruction");
   TTask *phosrec  = new TTask("phosRec","Phos Reconstruction");
   TTask *richrec  = new TTask("richRec","Rich Reconstruction");
   TTask *trdrec   = new TTask("trdRec","TRD Reconstruction");
   TTask *globrec  = new TTask("globRec","Global Track Reconstruction");
   TTask *pstats   = new TTask("printStats","Print Run Statistics");
   TTask *run      = new TTask("run","Process one run");
   TTask *event    = new TTask("event","Process one event");
   aliroot->Add(geominit);
   aliroot->Add(matinit);
   aliroot->Add(physinit);
   aliroot->Add(run);
   run->Add(event);
   event->Add(tracker);
   event->Add(muonrec);
   event->Add(phosrec);
   event->Add(richrec);
   event->Add(trdrec);
   event->Add(globrec);
   tracker->Add(tpcrec);
   tracker->Add(itsrec);
   run->Add(pstats);

   gROOT->GetListOfBrowsables()->Add(aliroot,"aliroot");
   new TBrowser;
} //-------------------------------------------------------------

 Default constructor invoked when reading a TTask object from a file.

 Standard constructor.

 Delete a task and its subtasks.

 Abort current tree of tasks.
 After this call, the tree of tasks is ready to be executed again.
 The application must take care of cleaning data structures created
 by previous executions.

 Browse the list of tasks.
 It is recommended to add the top level task to the list of
 ROOT browsables by:
    gROOT->GetListOfBrowsables()->Add(myTopLevelTask)

 Reset tasks state: breakpoints and execute flags
 also invokes the Clear function of each task to clear all data
 structures created by a previous execution of a task.

 Recursively call the Clear function of this task and its subtasks.
 The Clear function must be implemented for each derived class
 to clear all data structures created by a previous execution of a task.
 This function is automatically called by the CleanTasks function.

 Resume execution at the current break point.

 Dummy Execute.
 This function must be redefined in the derived classes.

 Execute main task and its subtasks.
 When calling this function, the Exec function of the corresponding class
 is invoked, then the list of its subtasks is executed calling recursively
 all the subtasks, etc.

 The option parameter may be used to select different execution steps
 within a task. This parameter is passed also to all the subtasks.

 Execute all the subtasks of a task.

 List the tree of tasks.
 Indentation is used to identify the task tree.

Inline Functions

               void Add(TTask* task)
              Int_t GetBreakin() const
              Int_t GetBreakout() const
             Bool_t IsActive() const
             Bool_t IsFolder() const
               void SetActive(Bool_t active = kTRUE)
               void SetBreakin(Int_t breakin = 1)
               void SetBreakout(Int_t breakout = 1)
             TList* GetListOfTasks() const
            TClass* Class()
            TClass* IsA() const
               void ShowMembers(TMemberInspector& insp, char* parent)
               void Streamer(TBuffer& b)
               void StreamerNVirtual(TBuffer& b)
             TTask& operator=(const TTask&)