MeVis/Foundation/Sources/MLBackgroundTasks/mlBackgroundTaskManager.h

Go to the documentation of this file.

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


#ifndef __mlBackgroundTaskManager_H
#define __mlBackgroundTaskManager_H


// Local includes
#include "MLBackgroundTasksSystem.h"

// ML includes
#include "mlModuleIncludes.h"

#include "mlBackgroundTask.h"
#include "mlBackgroundTaskMessageQueue.h"
#include "mlBackgroundTaskHandle.h"

#include <vector>
#include <deque>

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

#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);


  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