BatchAlgorithmRunner.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2021 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 +
#pragma once
 
#include "DllOption.h"
#include "IConfiguredAlgorithm.h"
#include "MantidAPI/Algorithm.h"
 
#include <QObject>
 
#include <Poco/ActiveMethod.h>
#include <Poco/ActiveResult.h>
#include <Poco/NObserver.h>
#include <Poco/Void.h>
 
#include <QMetaType>
#include <deque>
#include <mutex>
#include <utility>
 
namespace MantidQt::API {
 
class BatchCompleteNotification : public Poco::Notification {
public:
  BatchCompleteNotification(bool inProgress, bool error)
      : Poco::Notification(), m_inProgress(inProgress), m_error(error) {}
 
  bool isInProgress() const { return m_inProgress; }
  bool hasError() const { return m_error; }
 
private:
  bool m_inProgress;
  bool m_error;
};
 
class BatchCancelledNotification : public Poco::Notification {
public:
  BatchCancelledNotification() : Poco::Notification() {}
};
 
class AlgorithmCompleteNotification : public Poco::Notification {
public:
  AlgorithmCompleteNotification(IConfiguredAlgorithm_sptr algorithm)
      : Poco::Notification(), m_algorithm(std::move(algorithm)) {}
 
  IConfiguredAlgorithm_sptr algorithm() const { return m_algorithm; }
 
private:
  IConfiguredAlgorithm_sptr m_algorithm;
};
 
class AlgorithmStartedNotification : public Poco::Notification {
public:
  AlgorithmStartedNotification(IConfiguredAlgorithm_sptr algorithm)
      : Poco::Notification(), m_algorithm(std::move(algorithm)) {}
 
  IConfiguredAlgorithm_sptr algorithm() const { return m_algorithm; }
 
private:
  IConfiguredAlgorithm_sptr m_algorithm;
};
 
class AlgorithmErrorNotification : public Poco::Notification {
public:
  AlgorithmErrorNotification(IConfiguredAlgorithm_sptr algorithm, std::string const &errorMessage)
      : Poco::Notification(), m_algorithm(std::move(algorithm)), m_errorMessage(errorMessage) {}
 
  IConfiguredAlgorithm_sptr algorithm() const { return m_algorithm; }
  const std::string &errorMessage() const { return m_errorMessage; }
 
private:
  IConfiguredAlgorithm_sptr m_algorithm;
  std::string m_errorMessage;
};
 
class EXPORT_OPT_MANTIDQT_COMMON BatchAlgorithmRunner : public QObject {
  Q_OBJECT
 
public:
  explicit BatchAlgorithmRunner(QObject *parent = nullptr);
  ~BatchAlgorithmRunner() override;
 
  void addAlgorithm(const Mantid::API::IAlgorithm_sptr &algo);
  void addAlgorithm(const Mantid::API::IAlgorithm_sptr &algo,
                    std::unique_ptr<Mantid::API::IAlgorithmRuntimeProps> props);
 
  void setQueue(std::deque<IConfiguredAlgorithm_sptr> algorithm);
  void clearQueue();
  size_t queueLength();
 
  bool executeBatch();
  void executeBatchAsync();
  void executeAlgorithmAsync(IConfiguredAlgorithm_sptr algorithm);
  void cancelBatch();
 
  void stopOnFailure(bool stopOnFailure);
 
signals:
  void batchComplete(bool error);
  void batchCancelled();
  void algorithmStarted(MantidQt::API::IConfiguredAlgorithm_sptr algorithm);
  void algorithmComplete(MantidQt::API::IConfiguredAlgorithm_sptr algorithm);
  void algorithmError(MantidQt::API::IConfiguredAlgorithm_sptr algorithm, std::string errorMessage);
 
private:
  bool executeBatchAsyncImpl(const Poco::Void & /*unused*/);
  bool executeAlgo(const IConfiguredAlgorithm_sptr &algorithm);
  void postNotification(Poco::Notification *notification);
  // Sets cancel requested flag
  void setCancelRequested(bool const cancel);
 
  void handleBatchComplete(const Poco::AutoPtr<BatchCompleteNotification> &pNf);
  void handleBatchCancelled(const Poco::AutoPtr<BatchCancelledNotification> &pNf);
  void handleAlgorithmStarted(const Poco::AutoPtr<AlgorithmStartedNotification> &pNf);
  void handleAlgorithmComplete(const Poco::AutoPtr<AlgorithmCompleteNotification> &pNf);
  void handleAlgorithmError(const Poco::AutoPtr<AlgorithmErrorNotification> &pNf);
 
  std::deque<IConfiguredAlgorithm_sptr> m_algorithms;
 
  Mantid::API::IAlgorithm_sptr m_currentAlgorithm;
 
  bool m_stopOnFailure;
 
  bool m_cancelRequested;
  std::recursive_mutex m_executeMutex;
  std::recursive_mutex m_cancelMutex;
  std::recursive_mutex m_notificationMutex;
  void resetState();
  bool cancelRequested();
 
  mutable Poco::NotificationCenter m_notificationCenter;
  Poco::NObserver<BatchAlgorithmRunner, BatchCompleteNotification> m_batchCompleteObserver;
  Poco::NObserver<BatchAlgorithmRunner, BatchCancelledNotification> m_batchCancelledObserver;
  Poco::NObserver<BatchAlgorithmRunner, AlgorithmStartedNotification> m_algorithmStartedObserver;
  Poco::NObserver<BatchAlgorithmRunner, AlgorithmCompleteNotification> m_algorithmCompleteObserver;
  Poco::NObserver<BatchAlgorithmRunner, AlgorithmErrorNotification> m_algorithmErrorObserver;
 
  Poco::ActiveMethod<bool, Poco::Void, BatchAlgorithmRunner, Poco::ActiveStarter<BatchAlgorithmRunner>> m_executeAsync;
  Poco::ActiveResult<bool> executeAsync();
 
  void addAllObservers();
  void removeAllObservers();
};
} // namespace MantidQt::API