mlBackgroundTask.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2009, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_BACKGROUND_TASK_H
#define ML_BACKGROUND_TASK_H
 
// Local includes
#include "MLBackgroundTasksSystem.h"
 
#include "mlBackgroundTaskMessageQueue.h"
#include <mlTimeCounter.h>
 
#include <ThirdPartyWarningsDisable.h>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <ThirdPartyWarningsRestore.h>
 
ML_START_NAMESPACE
 
//-----------------------------------------------------------------------
class NotifyField;
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();

  bool 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