MeVis/Foundation/Sources/MLBackgroundTasks/mlBackgroundTask.h

Go to the documentation of this file.

// **InsertLicense** code
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------


#ifndef __mlBackgroundTask_H
#define __mlBackgroundTask_H


// Local includes
#include "MLBackgroundTasksSystem.h"

#include "mlBackgroundTaskMessageQueue.h"
#include "mlTimeCounter.h"

#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>

ML_START_NAMESPACE

//-----------------------------------------------------------------------
class BackgroundTask;
class BackgroundTaskMessage;
class BackgroundTaskStatusInformation;

typedef void BackgroundTaskFinishedCB(void *data, BackgroundTask *task);

//-----------------------------------------------------------------------
class MLBACKGROUNDTASKS_EXPORT BackgroundTask
{
  ML_DISALLOW_COPY_AND_ASSIGN(BackgroundTask)

public:
  enum Status {
    NotInTaskManager,
    Queued,
    Running,
    Finished,
    Canceled,
    Suspended
  };

  BackgroundTask(void* owner);
  virtual ~BackgroundTask();
 
  //------------------------------------------------------

  //------------------------------------------------------

  virtual void run() = 0;


  //------------------------------------------------------

  //------------------------------------------------------
  
  bool isSynchronous() const { return _synchronous; }
  void setSynchronous(bool flag) {
    _synchronous = flag;
  }

  void setSynchronousCancelField(NotifyField* field) { _synchronousCancelField = field; }


  //------------------------------------------------------

  //------------------------------------------------------

  Status status() const;

  void cancel();

  bool isCanceled() const;

  bool shouldStop();

  void resume();

  void suspend();

  std::string statusString() const;

  virtual void setStatusString(const std::string& status);

  float progress() const;

  virtual void setProgress(float progress);


  //------------------------------------------------------

  //------------------------------------------------------

  void setOwnerWasDeleted();

  bool hasOwner() const;

  void* owner() const;


  //------------------------------------------------------

  //------------------------------------------------------

  void waitAndExecuteNextMessage();

  void executeNextMessage();

  void sendMessageToGUI(BackgroundTaskMessage* message);


  //------------------------------------------------------

  //------------------------------------------------------

  void logMessage(const std::string& message);

  bool isVerbose() const { return _verbose; }
  void setVerbose(bool flag) {
    _verbose = flag;
  }


  //------------------------------------------------------

  //------------------------------------------------------
  double runningTime() const { return _runningTime; }

  double idleTime() const { return _idleTime; }

  void getStatusInformation(BackgroundTaskStatusInformation& info);

  MLuint32 taskId() const { return _taskId; }


  //------------------------------------------------------

  //------------------------------------------------------

  void setTaskFinishedCB(BackgroundTaskFinishedCB* callback, void* userdata);


  class Observer
  {
  public:
    virtual ~Observer() { }

    virtual void statusChanged(BackgroundTask* task, double elapsedSeconds, BackgroundTask::Status status) = 0;

    virtual void statusStringChanged(BackgroundTask* task, double elapsedSeconds, const std::string& status) = 0;

    virtual void logMessage(BackgroundTask* task, double elapsedSeconds, const std::string& message) = 0;
  };

  void addObserver(Observer* observer);
  void removeObserver(Observer* observer);


protected:

  void sendStatusChangedToObservers();
  void sendStatusStringChangedToObservers();
  void sendLogMessageToObservers(const std::string& msg);

  void addIdleTime(double timeInSecs) { _idleTime += timeInSecs; }

private:
  friend class  BackgroundTaskManager;
  friend struct BackgroundTaskManagerWorkerFunc;

  void runTask();

  void aboutToRun();

  void aboutToFinish();

  BackgroundTaskMessage* waitForMessage();

  void putMessageIntoQueue(BackgroundTaskMessage* message);

  void setStatus(Status status);

  void setStatusIfNotCanceledOrSuspended(Status status);

  void setStatusNoLock(Status status);

  void runTaskFinishedCallback();

  Status      _status;
  std::string _statusString;
  float       _progress;
  mutable boost::mutex _statusMonitor;
  boost::condition     _statusNoLongerSuspended;

  void*       _owner;

  TimeCounter _performanceTimer;
  double      _runningTime;
  double      _idleTime;

  BackgroundTaskFinishedCB* _taskFinishedCB;
  void* _taskFinishedCBUserData;

  BackgroundTaskMessageQueue _messageQueue;

  MLuint32 _taskId;

  std::vector<Observer*> _observers;

  bool _verbose;
  
  bool _synchronous;

  NotifyField* _synchronousCancelField;

};


ML_END_NAMESPACE

#endif