mlBackgroundTaskManager.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_MANAGER_H
#define ML_BACKGROUND_TASK_MANAGER_H
 
// Local includes
#include "MLBackgroundTasksSystem.h"
 
// ML includes
#include <mlModuleIncludes.h>
 
#include "mlBackgroundTask.h"
#include "mlBackgroundTaskMessageQueue.h"
#include "mlBackgroundTaskHandle.h"
 
#include <ThirdPartyWarningsDisable.h>
#include <vector>
#include <deque>
 
#include <ThirdPartyWarningsRestore.h>
#include <boost/thread.hpp>
#include <boost/thread/condition.hpp>
#include <boost/thread/mutex.hpp>
#include <cassert>
 
#ifdef _DEBUG
#define ML_ENSURE_GUITHREAD assert(ML_NAMESPACE::BackgroundTaskManager::ensureGUIThread());
#define ML_ENSURE_WORKERTHREAD assert(ML_NAMESPACE::BackgroundTaskManager::ensureWorkerThread());
#else
#define ML_ENSURE_GUITHREAD
#define ML_ENSURE_WORKERTHREAD
#endif
 
ML_START_NAMESPACE
 
class BackgroundTaskManagerPrivate;
class BackgroundTaskMessage;
class PageRequestProcessor;
 
typedef void BackgroundTaskScheduleProcessPendingMessagesCB(void *data);
 
class MLBACKGROUNDTASKS_EXPORT BackgroundTaskManager
{
  ML_DISALLOW_COPY_AND_ASSIGN(BackgroundTaskManager)
 
public:
  static BackgroundTaskManager& self();
 
  static void init();
 
  static void cleanup();
 
  BackgroundTaskHandle runTask(BackgroundTask* task);
 
  int totalTaskCount();
 
  void getStatusInformation(std::vector<BackgroundTaskStatusInformation>& infos);
 
  void sendMessageToGUI(BackgroundTaskMessage* message);
 
  void sendMessageToTask(BackgroundTask* task, BackgroundTaskMessage* message);
 
  static bool ensureGUIThread();
 
  static bool ensureWorkerThread();
 
  bool hasSynchronousTask() const { return _synchronousTaskRunning; }
 
  bool processPendingMessages();
 
  void cancelPendingRequestsForTask(BackgroundTask* task);
 
  void removeMessagesForReceiver(BackgroundTaskMessageReceiver* receiver);
 
 
  class Observer
  {
  public:
    virtual ~Observer() { }
 
    virtual void taskAdded(BackgroundTask* task) = 0;
    virtual void taskRemoved(BackgroundTask* task) = 0;
 
 
    virtual void taskStatusUpdated() = 0;
  };
 
  void addObserver(Observer* observer);
 
  void removeObserver(Observer* observer);
 
  PageRequestProcessor& getPageRequestProcessor();
 
  void setBackgroundTaskScheduleProcessPendingMessagesCB(
    BackgroundTaskScheduleProcessPendingMessagesCB* cb,
    void* userData);
 
  void getBackgroundTaskScheduleProcessPendingMessagesCB(
    BackgroundTaskScheduleProcessPendingMessagesCB** cb,
    void** userData);
 
  bool supportsAsynchronousTasks();
 
protected:
  friend struct BackgroundTaskManagerWorkerFunc;
  friend class  BackgroundTaskFinishedMessage;
  friend class  BackgroundTask;
 
  MLuint32 getUniqueTaskId();
 
  void sendTaskAdded(BackgroundTask* task);
 
  void sendTaskRemoved(BackgroundTask* task);
 
  void sendTaskStatusUpdated();
 
  void removeTaskFromQueueAndSendTaskFinished(BackgroundTask* task);
 
  BackgroundTask* waitForTask();
 
  void sendTaskFinishedMessage(BackgroundTask* task);
 
private:
  void createWorkerThreads();
 
  void taskFinished(BackgroundTask* task);
 
  bool removeTaskFromQueue(BackgroundTask* task);
 
  BackgroundTaskManager();
  ~BackgroundTaskManager();
  friend class BackgroundTaskManagerPrivate;
 
  static BackgroundTaskManager* _manager;
 
  bool                          _synchronousTaskRunning;
 
  std::vector<boost::thread*>   _threads;
 
  std::vector<BackgroundTask*>  _tasks;
 
  std::deque<BackgroundTask*>   _taskQueue;
  boost::condition              _taskAvailable;
  boost::mutex                  _taskQueueMonitor;
 
  MLuint32                      _uniqueTaskId;
  boost::mutex                  _uniqueTaskIdMonitor;
 
  std::vector<Observer*> _observers;
 
  BackgroundTaskScheduleProcessPendingMessagesCB* _scheduleProcessPendingMessagesCB;
  void*                                       _scheduleProcessPendingMessagesCBUserData;
 
  BackgroundTaskManagerPrivate* _private;
 
};
 
 
ML_END_NAMESPACE
 
#endif