VisibleWhenProperty.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 "MantidKernel/VisibleWhenProperty.h"
 
#include <memory>
#include <set>
#include <stdexcept>
 
namespace Mantid::Kernel {
 
VisibleWhenProperty::VisibleWhenProperty(const std::string &otherPropName, ePropertyCriterion when,
                                         const std::string &value)
    : EnabledWhenProperty(otherPropName, when, value) {}
 
VisibleWhenProperty::VisibleWhenProperty(const VisibleWhenProperty &conditionOne,
                                         const VisibleWhenProperty &conditionTwo, eLogicOperator logicOperator)
    : // For the python interface to be able to easily copy objects in
      // Make a deep copy and turn into a shared pointer and forward on
      VisibleWhenProperty(std::make_shared<VisibleWhenProperty>(conditionOne),
                          std::make_shared<VisibleWhenProperty>(conditionTwo), logicOperator) {}
 
VisibleWhenProperty::VisibleWhenProperty(std::shared_ptr<VisibleWhenProperty> &&conditionOne,
                                         std::shared_ptr<VisibleWhenProperty> &&conditionTwo,
                                         eLogicOperator logicOperator)
    : m_comparisonDetails{std::make_shared<ComparisonDetails<VisibleWhenProperty>>(
          ComparisonDetails<VisibleWhenProperty>{std::move(conditionOne), std::move(conditionTwo), logicOperator})} {}
 
bool VisibleWhenProperty::checkComparison(const IPropertyManager *algo) const {
  const auto &comparison = m_comparisonDetails;
  const auto &objectOne = comparison->conditionOne;
  const auto &objectTwo = comparison->conditionTwo;
 
  switch (comparison->logicOperator) {
  case AND:
    return objectOne->isVisible(algo) && objectTwo->isVisible(algo);
    break;
  case OR:
    return objectOne->isVisible(algo) || objectTwo->isVisible(algo);
    break;
  case XOR:
    return objectOne->isVisible(algo) ^ objectTwo->isVisible(algo);
    break;
  default:
    throw std::runtime_error("Unknown logic operator in EnabledWhenProperty");
  }
}
 
bool VisibleWhenProperty::isEnabled(const IPropertyManager *algo) const {
  UNUSED_ARG(algo);
  return true;
}
 
bool VisibleWhenProperty::isVisible(const IPropertyManager *algo) const {
  if (m_propertyDetails) {
    return checkCriterion(algo);
  } else if (m_comparisonDetails) {
    return checkComparison(algo);
  } else {
    throw std::runtime_error("Both PropertyDetails and ComparisonDetails were "
                             "null in VisibleWhenProperty");
  }
}
 
std::vector<std::string> VisibleWhenProperty::dependsOn(const std::string &thisProp) const {
  if (m_propertyDetails) {
    const std::string &otherProp = m_propertyDetails->otherPropName;
    if (otherProp == thisProp)
      throw std::runtime_error("VisibleWhenProperty: circular dependency detected");
    return std::vector<std::string>{otherProp};
  } else if (m_comparisonDetails) {
    std::set<std::string> ps;
    const auto ps1 = m_comparisonDetails->conditionOne->dependsOn(thisProp);
    const auto ps2 = m_comparisonDetails->conditionTwo->dependsOn(thisProp);
    ps.insert(ps1.cbegin(), ps1.cend());
    ps.insert(ps2.cbegin(), ps2.cend());
    return std::vector<std::string>(ps.cbegin(), ps.cend());
  } else
    return std::vector<std::string>{};
}
 
IPropertySettings *VisibleWhenProperty::clone() const { return new VisibleWhenProperty(*this); }
 
} // namespace Mantid::Kernel