EnabledWhenWorkspaceIsType.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2011 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 <utility>
 
#include "MantidAPI/AnalysisDataService.h"
#include "MantidAPI/DllConfig.h"
#include "MantidAPI/Workspace_fwd.h"
#include "MantidKernel/DataService.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/IPropertySettings.h"
#include "MantidKernel/SingletonHolder.h"
 
namespace Mantid {
namespace API {
 
template <typename T> class DLLExport EnabledWhenWorkspaceIsType : public Kernel::IPropertySettings {
public:
  //--------------------------------------------------------------------------------------------
  EnabledWhenWorkspaceIsType(std::string otherPropName, bool enabledSetting = true)
      : IPropertySettings(), m_otherPropName(std::move(otherPropName)), m_enabledSetting(enabledSetting) {}
 
  //--------------------------------------------------------------------------------------------
  virtual bool checkCriterion(const Kernel::IPropertyManager *algo) const {
    // Find the property
    if (!algo)
      return true;
    Mantid::Kernel::Property const *prop = nullptr;
    try {
      prop = algo->getPointerToProperty(m_otherPropName);
    } catch (Mantid::Kernel::Exception::NotFoundError &) {
      return true; // Property not found. Ignore
    }
    if (!prop)
      return true;
 
    // Value of the other property
    std::string propValue = prop->value();
    if (propValue.empty())
      return true;
 
    Workspace_sptr ws;
    try {
      ws = Mantid::API::AnalysisDataService::Instance().retrieve(propValue);
    } catch (...) {
      return true;
    }
    // Does it cast to the desired type?
    std::shared_ptr<T> castWS = std::dynamic_pointer_cast<T>(ws);
    if (castWS)
      return m_enabledSetting;
    else
      return !m_enabledSetting;
  }
 
  //--------------------------------------------------------------------------------------------
  bool isEnabled(const Kernel::IPropertyManager *algo) const override { return checkCriterion(algo); }
 
  //--------------------------------------------------------------------------------------------
  bool isVisible(const Kernel::IPropertyManager *) const override { return true; }
 
  //--------------------------------------------------------------------------------------------
  std::vector<std::string> dependsOn(const std::string &thisProp) const override {
    if (m_otherPropName == thisProp)
      throw std::runtime_error("EnabledWhenWorkspaceIsType: circular dependency detected");
    return std::vector<std::string>{m_otherPropName};
  }
 
  //--------------------------------------------------------------------------------------------
  IPropertySettings *clone() const override {
    return new EnabledWhenWorkspaceIsType<T>(m_otherPropName, m_enabledSetting);
  }
 
protected:
  std::string m_otherPropName;
  bool m_enabledSetting;
};
 
} // namespace API
} // namespace Mantid