task.h

Go to the documentation of this file.

#ifndef task_h
#define task_h

/*+
________________________________________________________________________

 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        A.H.Bril/K.Tingdahl
 Date:          13-10-1999
 RCS:           $Id$
________________________________________________________________________

-*/

#include "basicmod.h"
#include "namedobj.h"
#include "objectset.h"
#include "threadlock.h"
#include "uistring.h"

class ProgressMeter;
namespace Threads { class ConditionVar; }


mExpClass(Basic) Task : public NamedObject
{ mODTextTranslationClass(Task);
public:

    virtual             ~Task();

    virtual void        setProgressMeter(ProgressMeter*)        {}

    virtual od_int64    nrDone() const                  { return -1; }
    virtual od_int64    totalNr() const                 { return -1; }
    virtual uiString    uiMessage() const; 
    virtual uiString    uiNrDoneText() const; 
    static uiString     stdNrDoneText() { return tr("Nr Done"); }
    static uiString     uiStdNrDoneText() { return tr("Nr Done"); }
                        //< will disappear

    virtual bool        execute()                       = 0;

    enum Control        { Run, Pause, Stop };
    virtual void        enableWorkControl(bool=true);
    bool                workControlEnabled() const;
    virtual void        controlWork(Control);
    virtual Control     getState() const;

protected:

                                Task(const char* nm=0);
    virtual bool                shouldContinue();
    Control                     control_;
    Threads::ConditionVar*      workcontrolcondvar_;

private:

    //In 7.0, this function will return a uiString
    virtual const char* message() const                 { return 0; }
    //In 7.0, this function will return a uiString
    virtual const char* nrDoneText() const              { return 0; }

};


mExpClass(Basic) TaskGroup : public Task
{
public:
                        TaskGroup();
                        ~TaskGroup() { deepErase( tasks_ ); cleanUp(); }
    void                addTask( Task* );
                        //Becomes mine

    void                setParallel(bool);
    void                showCumulativeCount(bool yn);
    void                setEmpty();
    void                getTasks(TaskGroup&);

    void                setProgressMeter(ProgressMeter*);
    virtual od_int64    nrDone() const;
    virtual od_int64    totalNr() const;

    uiString            uiMessage() const;
    uiString            uiNrDoneText() const;

    virtual bool        execute();

    void                enableWorkControl(bool=true);
    virtual void        controlWork(Control);
    virtual Control     getState() const;

protected:

    ObjectSet<Task>     tasks_;
    int                 curtask_;

    mutable Threads::Lock lock_;

private:
    void                cleanUp();
};


mExpClass(Basic) SequentialTask : public Task
{
public:
                SequentialTask(const char* nm=0);
    virtual     ~SequentialTask();

    void        setProgressMeter(ProgressMeter*);
    ProgressMeter* progressMeter()              { return progressmeter_; }
    const ProgressMeter* progressMeter() const  { return progressmeter_; }

    virtual int doStep();
    static int  ErrorOccurred()                         { return -1; }
    static int  Finished()                              { return 0; }
    static int  MoreToDo()                              { return 1; }
    static int  WarningAvailable()                      { return 2; }

    bool        execute();

protected:

    virtual int nextStep()                              = 0;
    ProgressMeter* progressmeter_;
    int                 lastupdate_;
};



mExpClass(Basic) TaskRunner
{
public:
    static bool         execute(TaskRunner* tr, Task& );

                        TaskRunner() : execres_(false)  {}
    virtual             ~TaskRunner()                   {}

    virtual bool        execute(Task& t)
                        { return (execres_ = t.execute()); }
    virtual bool        execResult() const              { return execres_; }

protected:

    bool                execres_;

};


#endif