cxThreadedTimedAlgorithm.h

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#ifndef CXTHREADEDTIMEDALGORITHM_H_
#define CXTHREADEDTIMEDALGORITHM_H_
 
#include "cxResourceExport.h"
 
#include <QFutureWatcher>
#include <QtConcurrent/QtConcurrentRun>
 
#include "cxTimedAlgorithm.h"
 
#include "vtkForwardDeclarations.h"
#include "cxForwardDeclarations.h"
 
namespace cx
{
 
template <class T>
class cxResource_EXPORT ThreadedTimedAlgorithm : public TimedBaseAlgorithm
{
public:
  ThreadedTimedAlgorithm(QString product, int secondsBetweenAnnounce) :
          TimedBaseAlgorithm(product, secondsBetweenAnnounce)
  {
          connect(&mWatcher, SIGNAL(finished()), this, SLOT(finishedSlot()));
          connect(&mWatcher, SIGNAL(finished()), this, SLOT(postProcessingSlot()));
          connect(&mWatcher, SIGNAL(finished()), this, SIGNAL(finished()));
  }
  virtual ~ThreadedTimedAlgorithm() {}
 
  virtual void execute()
  {
        emit aboutToStart();
        this->preProcessingSlot();
        this->generate();
  }
  virtual bool isFinished() const { return mWatcher.isFinished(); }
  virtual bool isRunning() const { return mWatcher.isRunning(); }
 
 
protected:
  virtual void preProcessingSlot() {} 
  virtual void postProcessingSlot() = 0; 
 
protected:
  virtual T calculate() = 0; 
 
  void generate() 
  {
          TimedBaseAlgorithm::startTiming();
          emit started(0); // TODO move to started signal from qtconcurrent??
 
          mFutureResult = QtConcurrent::run(this, &ThreadedTimedAlgorithm<T>::calculate);
          mWatcher.setFuture(mFutureResult);
  }
  T getResult() 
  {
          T result = mWatcher.future().result();
          return result;
  }
 
private:
  void finishedSlot()
  {
          TimedBaseAlgorithm::stopTiming();
  }
 
  QFuture<T> mFutureResult;
  QFutureWatcher<T> mWatcher;
};
 
//template specicalizations
template<>
cxResource_EXPORT void ThreadedTimedAlgorithm<void>::getResult();
 
//---------------------------------------------------------------------------------------------------------------------
class Example : public ThreadedTimedAlgorithm<QString>
{
  Q_OBJECT
public:
  Example();
  virtual ~Example();
 
private slots:
  virtual void postProcessingSlot();
 
private:
  virtual QString calculate();
};
 
}//namespace
 
 
#endif /* CXTHREADEDTIMEDALGORITHM_H_ */