task.h

Go to the documentation of this file.

#pragma once
 
/*+
________________________________________________________________________
 
 (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 NamedCallBacker
{ mODTextTranslationClass(Task)
public:
 
    virtual             ~Task();
 
    virtual void        setProgressMeter(ProgressMeter*)        {}
 
    virtual uiString    uiMessage() const; 
    virtual uiString    uiNrDoneText() const; 
    virtual od_int64    nrDone() const                  { return -1; }
    virtual od_int64    totalNr() const                 { return -1; }
    virtual uiRetVal    errorWithDetails() const { return uiRetVal(uiMessage()); }
 
    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=nullptr);
    virtual bool                shouldContinue();
    Control                     control_;
    Threads::ConditionVar*      workcontrolcondvar_;
 
private:
 
    //In 7.0, this function will return a uiString
    virtual const char* message() const                 { return nullptr; }
    //In 7.0, this function will return a uiString
    virtual const char* nrDoneText() const              { return nullptr; }
 
};
 
 
mExpClass(Basic) TaskGroup : public Task
{
public:
                        TaskGroup();
            ~TaskGroup();
 
    void                addTask( Task* );
                        //Becomes mine
 
    void                setParallel(bool);
    void                showCumulativeCount( bool yn ) { cumulativecount_ = 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_;
    bool        cumulativecount_ = false;
 
    mutable Threads::Lock lock_;
 
};
 
 
mExpClass(Basic) SequentialTask : public Task
{
public:
                SequentialTask(const char* nm=nullptr);
    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_;
 
};