library: libCore #include "TTask.h"

# TTask

class description - source file - inheritance tree (.ps)

## class TTask : public TNamed

| Inheritance Chart:

`TObject`

<-

`TNamed`

<-

`TTask`

        public:

                          TTask()
                          TTask(const char* name, const char* title)
                          TTask(const TTask& task)
                  virtual ~TTask()
                     void Abort()
                     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;
    } //-------------------------------------------------------------

/* */

TTask()

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

TTask(const char* name, const char *title) : TNamed(name,title)

     Standard constructor.

~TTask()

     Delete a task and its subtasks.

TTask(const TTask &task) : TNamed(task)

void Abort()

     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.

void Browse(TBrowser *b)

     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)

void CleanTasks()

     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.

void Clear(Option_t *)

     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.

void Continue()

     Resume execution at the current break point.

void Exec(Option_t *)

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

void ExecuteTask(Option_t *option)

     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.

void ExecuteTasks(Option_t *option)

     Execute all the subtasks of a task.

void ls(Option_t *option) const

     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&)

Author: Rene Brun 02/09/2000
Last update: root/base:$Name: $:$Id: TTask.cxx,v 1.11 2003/10/13 18:24:22 rdm Exp $
Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *