AlgorithmObserver.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 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include <utility>
 
#include "MantidAPI/AlgorithmManager.h"
#include "MantidAPI/AlgorithmObserver.h"
 
namespace Mantid::API {
 
AlgorithmObserver::AlgorithmObserver()
    : m_progressObserver(*this, &AlgorithmObserver::_progressHandle),
      m_startObserver(*this, &AlgorithmObserver::_startHandle),
      m_finishObserver(*this, &AlgorithmObserver::_finishHandle),
      m_errorObserver(*this, &AlgorithmObserver::_errorHandle),
      m_startingObserver(*this, &AlgorithmObserver::_startingHandle) {}
 
AlgorithmObserver::AlgorithmObserver(const IAlgorithm_const_sptr &alg)
    : m_progressObserver(*this, &AlgorithmObserver::_progressHandle),
      m_startObserver(*this, &AlgorithmObserver::_startHandle),
      m_finishObserver(*this, &AlgorithmObserver::_finishHandle),
      m_errorObserver(*this, &AlgorithmObserver::_errorHandle),
      m_startingObserver(*this, &AlgorithmObserver::_startingHandle) {
  observeAll(alg);
}
 
AlgorithmObserver::~AlgorithmObserver() = default;
 
void AlgorithmObserver::observeAll(const IAlgorithm_const_sptr &alg) {
  alg->addObserver(m_progressObserver);
  alg->addObserver(m_startObserver);
  alg->addObserver(m_finishObserver);
  alg->addObserver(m_errorObserver);
}
 
void AlgorithmObserver::observeProgress(const IAlgorithm_const_sptr &alg) { alg->addObserver(m_progressObserver); }
 
void AlgorithmObserver::observeStarting() {
  AlgorithmManager::Instance().notificationCenter.addObserver(m_startingObserver);
}
 
void AlgorithmObserver::observeStart(const IAlgorithm_const_sptr &alg) { alg->addObserver(m_startObserver); }
 
void AlgorithmObserver::observeFinish(const IAlgorithm_const_sptr &alg) { alg->addObserver(m_finishObserver); }
 
void AlgorithmObserver::observeError(const IAlgorithm_const_sptr &alg) { alg->addObserver(m_errorObserver); }
 
void AlgorithmObserver::stopObserving(const IAlgorithm_const_sptr &alg) { this->stopObserving(alg.get()); }
 
void AlgorithmObserver::stopObserving(const IAlgorithm *alg) {
  alg->removeObserver(m_progressObserver);
  alg->removeObserver(m_startObserver);
  alg->removeObserver(m_finishObserver);
  alg->removeObserver(m_errorObserver);
}
 
void AlgorithmObserver::stopObservingManager() {
  AlgorithmManager::Instance().notificationCenter.removeObserver(m_startingObserver);
}
 
 
void AlgorithmObserver::progressHandle(const IAlgorithm *alg, double p, const std::string &msg,
                                       const double estimatedTime, const int progressPrecision) {
  UNUSED_ARG(alg)
  UNUSED_ARG(p)
  UNUSED_ARG(msg)
  UNUSED_ARG(estimatedTime)
  UNUSED_ARG(progressPrecision)
}
 
void AlgorithmObserver::startingHandle(IAlgorithm_sptr alg) { UNUSED_ARG(alg) }
 
void AlgorithmObserver::startHandle(const IAlgorithm *alg) { UNUSED_ARG(alg) }
 
void AlgorithmObserver::finishHandle(const IAlgorithm *alg) { UNUSED_ARG(alg) }
 
void AlgorithmObserver::errorHandle(const IAlgorithm *alg, const std::string &what) {
  UNUSED_ARG(alg)
  UNUSED_ARG(what)
}
 
void AlgorithmObserver::_progressHandle(const Poco::AutoPtr<Algorithm::ProgressNotification> &pNf) {
  this->progressHandle(pNf->algorithm(), pNf->progress, pNf->message, pNf->estimatedTime, pNf->progressPrecision);
}
 
void AlgorithmObserver::_startHandle(const Poco::AutoPtr<Algorithm::StartedNotification> &pNf) {
  this->startHandle(pNf->algorithm());
}
 
void AlgorithmObserver::_finishHandle(const Poco::AutoPtr<Algorithm::FinishedNotification> &pNf) {
  this->finishHandle(pNf->algorithm());
}
 
void AlgorithmObserver::_errorHandle(const Poco::AutoPtr<Algorithm::ErrorNotification> &pNf) {
  this->errorHandle(pNf->algorithm(), pNf->what);
}
 
void AlgorithmObserver::_startingHandle(const Poco::AutoPtr<AlgorithmStartingNotification> &pNf) {
  this->startingHandle(pNf->getAlgorithm());
}
 
} // namespace Mantid::API