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