AlgorithmRunner.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidQtWidgets/Common/AlgorithmRunner.h"
 
#include <Poco/ActiveResult.h>
 
using namespace Mantid::Kernel;
using namespace Mantid::API;
 
namespace MantidQt::API {
 
//----------------------------------------------------------------------------------------------
AlgorithmRunner::AlgorithmRunner(QObject *parent)
    : QObject(parent), m_finishedObserver(*this, &AlgorithmRunner::handleAlgorithmFinishedNotification),
      m_progressObserver(*this, &AlgorithmRunner::handleAlgorithmProgressNotification),
      m_errorObserver(*this, &AlgorithmRunner::handleAlgorithmErrorNotification), m_asyncResult(nullptr) {}
 
//----------------------------------------------------------------------------------------------
AlgorithmRunner::~AlgorithmRunner() {
  if (m_asyncAlg) {
    m_asyncAlg->removeObserver(m_finishedObserver);
    m_asyncAlg->removeObserver(m_errorObserver);
    m_asyncAlg->removeObserver(m_progressObserver);
  }
  delete m_asyncResult;
}
 
//--------------------------------------------------------------------------------------
void AlgorithmRunner::cancelRunningAlgorithm() {
  // Cancel any currently running algorithms
  if (m_asyncAlg) {
    if (m_asyncAlg->isRunning()) {
      m_asyncAlg->cancel();
    }
    if (m_asyncResult) {
      m_asyncResult->tryWait(1000);
      delete m_asyncResult;
      m_asyncResult = nullptr;
    }
    m_asyncAlg->removeObserver(m_finishedObserver);
    m_asyncAlg->removeObserver(m_errorObserver);
    m_asyncAlg->removeObserver(m_progressObserver);
    m_asyncAlg.reset();
  }
}
 
//--------------------------------------------------------------------------------------
void AlgorithmRunner::startAlgorithm(Mantid::API::IAlgorithm_sptr alg) {
  if (!alg)
    throw std::invalid_argument("AlgorithmRunner::startAlgorithm() given a NULL Algorithm");
  if (!alg->isInitialized())
    throw std::invalid_argument("AlgorithmRunner::startAlgorithm() given an uninitialized Algorithm");
 
  cancelRunningAlgorithm();
 
  // Observe the algorithm
  alg->addObserver(m_finishedObserver);
  alg->addObserver(m_errorObserver);
  alg->addObserver(m_progressObserver);
  // Start asynchronous execution
  m_asyncAlg = alg;
  m_asyncResult = new Poco::ActiveResult<bool>(m_asyncAlg->executeAsync());
}
 
Mantid::API::IAlgorithm_sptr AlgorithmRunner::getAlgorithm() const { return m_asyncAlg; }
 
//--------------------------------------------------------------------------------------
void AlgorithmRunner::handleAlgorithmFinishedNotification(const Poco::AutoPtr<Algorithm::FinishedNotification> &pNf) {
  UNUSED_ARG(pNf);
  emit algorithmComplete(false);
}
 
//--------------------------------------------------------------------------------------
void AlgorithmRunner::handleAlgorithmProgressNotification(const Poco::AutoPtr<Algorithm::ProgressNotification> &pNf) {
  emit algorithmProgress(pNf->progress, pNf->message);
}
 
//--------------------------------------------------------------------------------------
void AlgorithmRunner::handleAlgorithmErrorNotification(const Poco::AutoPtr<Algorithm::ErrorNotification> &pNf) {
  UNUSED_ARG(pNf);
  emit algorithmComplete(true);
}
 
} // namespace MantidQt::API