AnalysisDataServiceObserver.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2019 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 "MantidAPI/AnalysisDataServiceObserver.h"
 
namespace {
template <typename Observer> void modifyObserver(const bool turnOn, bool &isObserving, Observer &observer) {
  if (turnOn && !isObserving) {
    AnalysisDataService::Instance().notificationCenter.addObserver(observer);
  } else if (!turnOn && isObserving) {
    AnalysisDataService::Instance().notificationCenter.removeObserver(observer);
  }
  isObserving = turnOn;
}
} // namespace
 
namespace Mantid::API {
 
AnalysisDataServiceObserver::AnalysisDataServiceObserver()
    : m_addObserver(*this, &AnalysisDataServiceObserver::_addHandle),
      m_replaceObserver(*this, &AnalysisDataServiceObserver::_replaceHandle),
      m_deleteObserver(*this, &AnalysisDataServiceObserver::_deleteHandle),
      m_clearObserver(*this, &AnalysisDataServiceObserver::_clearHandle),
      m_renameObserver(*this, &AnalysisDataServiceObserver::_renameHandle),
      m_groupObserver(*this, &AnalysisDataServiceObserver::_groupHandle),
      m_unGroupObserver(*this, &AnalysisDataServiceObserver::_unGroupHandle),
      m_groupUpdatedObserver(*this, &AnalysisDataServiceObserver::_groupUpdateHandle) {}
 
AnalysisDataServiceObserver::~AnalysisDataServiceObserver() {
  // Turn off/remove all observers
  this->observeAll(false);
}
 
// ------------------------------------------------------------
// Observe Methods
// ------------------------------------------------------------
 
void AnalysisDataServiceObserver::observeAll(bool turnOn) {
  this->observeAdd(turnOn);
  this->observeReplace(turnOn);
  this->observeDelete(turnOn);
  this->observeClear(turnOn);
  this->observeRename(turnOn);
  this->observeGroup(turnOn);
  this->observeUnGroup(turnOn);
  this->observeGroupUpdate(turnOn);
}
 
void AnalysisDataServiceObserver::observeAdd(bool turnOn) { modifyObserver(turnOn, m_observingAdd, m_addObserver); }
 
void AnalysisDataServiceObserver::observeReplace(bool turnOn) {
  modifyObserver(turnOn, m_observingReplace, m_replaceObserver);
}
 
void AnalysisDataServiceObserver::observeDelete(bool turnOn) {
  modifyObserver(turnOn, m_observingDelete, m_deleteObserver);
}
 
void AnalysisDataServiceObserver::observeClear(bool turnOn) {
  modifyObserver(turnOn, m_observingClear, m_clearObserver);
}
 
void AnalysisDataServiceObserver::observeRename(bool turnOn) {
  modifyObserver(turnOn, m_observingRename, m_renameObserver);
}
 
void AnalysisDataServiceObserver::observeGroup(bool turnOn) {
  modifyObserver(turnOn, m_observingGroup, m_groupObserver);
}
 
void AnalysisDataServiceObserver::observeUnGroup(bool turnOn) {
  modifyObserver(turnOn, m_observingUnGroup, m_unGroupObserver);
}
 
void AnalysisDataServiceObserver::observeGroupUpdate(bool turnOn) {
  modifyObserver(turnOn, m_observingGroupUpdate, m_groupUpdatedObserver);
}
 
// ------------------------------------------------------------
// Virtual Methods
// ------------------------------------------------------------
void AnalysisDataServiceObserver::anyChangeHandle() {}
 
void AnalysisDataServiceObserver::addHandle(const std::string &wsName, const Mantid::API::Workspace_sptr &ws) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(ws)
}
 
void AnalysisDataServiceObserver::replaceHandle(const std::string &wsName, const Mantid::API::Workspace_sptr &ws) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(ws)
}
 
void AnalysisDataServiceObserver::deleteHandle(const std::string &wsName, const Mantid::API::Workspace_sptr &ws) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(ws)
}
 
void AnalysisDataServiceObserver::clearHandle() {}
 
void AnalysisDataServiceObserver::renameHandle(const std::string &wsName, const std::string &newName) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(newName)
}
 
void AnalysisDataServiceObserver::groupHandle(const std::string &wsName, const Workspace_sptr &ws) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(ws)
}
 
void AnalysisDataServiceObserver::unGroupHandle(const std::string &wsName, const Workspace_sptr &ws) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(ws)
}
 
void AnalysisDataServiceObserver::groupUpdateHandle(const std::string &wsName, const Workspace_sptr &ws) {
  UNUSED_ARG(wsName)
  UNUSED_ARG(ws)
}
 
// ------------------------------------------------------------
// Private Methods
// ------------------------------------------------------------
void AnalysisDataServiceObserver::_addHandle(const Poco::AutoPtr<AnalysisDataServiceImpl::AddNotification> &pNf) {
  this->anyChangeHandle();
  this->addHandle(pNf->objectName(), pNf->object());
}
 
void AnalysisDataServiceObserver::_replaceHandle(
    const Poco::AutoPtr<AnalysisDataServiceImpl::AfterReplaceNotification> &pNf) {
  this->anyChangeHandle();
  this->replaceHandle(pNf->objectName(), pNf->object());
}
 
void AnalysisDataServiceObserver::_deleteHandle(
    const Poco::AutoPtr<AnalysisDataServiceImpl::PreDeleteNotification> &pNf) {
  this->anyChangeHandle();
  this->deleteHandle(pNf->objectName(), pNf->object());
}
 
void AnalysisDataServiceObserver::_clearHandle(const Poco::AutoPtr<AnalysisDataServiceImpl::ClearNotification> &pNf) {
  UNUSED_ARG(pNf)
  this->anyChangeHandle();
  this->clearHandle();
}
 
void AnalysisDataServiceObserver::_renameHandle(const Poco::AutoPtr<AnalysisDataServiceImpl::RenameNotification> &pNf) {
  this->anyChangeHandle();
  this->renameHandle(pNf->objectName(), pNf->newObjectName());
}
 
void AnalysisDataServiceObserver::_groupHandle(
    const Poco::AutoPtr<AnalysisDataServiceImpl::GroupWorkspacesNotification> &pNf) {
  this->anyChangeHandle();
  this->groupHandle(pNf->objectName(), pNf->object());
}
 
void AnalysisDataServiceObserver::_unGroupHandle(
    const Poco::AutoPtr<AnalysisDataServiceImpl::UnGroupingWorkspaceNotification> &pNf) {
  this->anyChangeHandle();
  this->unGroupHandle(pNf->objectName(), pNf->object());
}
 
void AnalysisDataServiceObserver::_groupUpdateHandle(
    const Poco::AutoPtr<AnalysisDataServiceImpl::GroupUpdatedNotification> &pNf) {
  this->anyChangeHandle();
  this->groupUpdateHandle(pNf->objectName(), pNf->object());
}
 
} // namespace Mantid::API