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_ */