EnabledWhenProperty.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/EnabledWhenProperty.h"
 
#include "MantidKernel/Exception.h"
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/Property.h"
 
#include <boost/lexical_cast.hpp>
 
#include <exception>
#include <memory>
#include <set>
#include <stdexcept>
 
using namespace Mantid::Kernel;
 
namespace Mantid::Kernel {
EnabledWhenProperty::EnabledWhenProperty(const std::string &otherPropName, const ePropertyCriterion when,
                                         const std::string &value)
    : IPropertySettings(),
      m_propertyDetails(std::make_shared<PropertyDetails>(PropertyDetails{otherPropName, when, value})) {}
 
EnabledWhenProperty::EnabledWhenProperty(const EnabledWhenProperty &conditionOne,
                                         const EnabledWhenProperty &conditionTwo, eLogicOperator logicOperator)
    : // This method allows the Python interface to easily construct these
      // objects
      // Copy the object then forward onto our move constructor
      EnabledWhenProperty(std::make_shared<EnabledWhenProperty>(conditionOne),
                          std::make_shared<EnabledWhenProperty>(conditionTwo), logicOperator) {}
 
EnabledWhenProperty::EnabledWhenProperty(std::shared_ptr<EnabledWhenProperty> &&conditionOne,
                                         std::shared_ptr<EnabledWhenProperty> &&conditionTwo,
                                         eLogicOperator logicOperator)
    : IPropertySettings(),
      m_comparisonDetails(std::make_shared<ComparisonDetails<EnabledWhenProperty>>(
          ComparisonDetails<EnabledWhenProperty>{std::move(conditionOne), std::move(conditionTwo), logicOperator})) {}
 
EnabledWhenProperty::EnabledWhenProperty(const EnabledWhenProperty &other)
    : IPropertySettings(), m_propertyDetails{other.m_propertyDetails}, m_comparisonDetails{other.m_comparisonDetails} {}
 
bool EnabledWhenProperty::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->isEnabled(algo) && objectTwo->isEnabled(algo);
    break;
  case OR:
    return objectOne->isEnabled(algo) || objectTwo->isEnabled(algo);
    break;
  case XOR:
    return objectOne->isEnabled(algo) ^ objectTwo->isEnabled(algo);
    break;
  default:
    throw std::runtime_error("Unknown logic operator in EnabledWhenProperty");
  }
}
 
bool EnabledWhenProperty::checkCriterion(const IPropertyManager *algo) const {
 
  // Value of the other property
  const std::string propValue = getPropertyValue(algo);
  // This is safe as long as getPropertyValue (which checks) has been called
  // already
  const auto *prop = algo->getPointerToProperty(m_propertyDetails->otherPropName);
 
  // OK, we have the property. Check the condition
  switch (m_propertyDetails->criterion) {
  case IS_DEFAULT:
    return prop->isDefault();
  case IS_NOT_DEFAULT:
    return !prop->isDefault();
  case IS_EQUAL_TO:
    return (propValue == m_propertyDetails->value);
  case IS_NOT_EQUAL_TO:
    return (propValue != m_propertyDetails->value);
  case IS_MORE_OR_EQ: {
    auto check = boost::lexical_cast<int>(m_propertyDetails->value);
    auto iPropV = boost::lexical_cast<int>(propValue);
    return (iPropV >= check);
  }
  default:
    // Unknown criterion
    std::string errString = "The EnabledWhenProperty criterion set"
                            " for the following property ";
    errString += m_propertyDetails->otherPropName;
    errString += " is unknown";
    throw std::invalid_argument(errString);
  }
}
 
std::string EnabledWhenProperty::getPropertyValue(const IPropertyManager *algo) const {
  // Find the property
  if (algo == nullptr)
    throw std::runtime_error("Algorithm properties passed to EnabledWhenProperty was null");
 
  Property const *prop = nullptr;
  try {
    prop = algo->getPointerToProperty(m_propertyDetails->otherPropName);
  } catch (Exception::NotFoundError &) {
    prop = nullptr; // Ensure we still have null pointer
  }
  if (!prop)
    throw std::runtime_error("Property " + m_propertyDetails->otherPropName + " was not found in EnabledWhenProperty");
  return prop->value();
}
 
bool EnabledWhenProperty::isEnabled(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 EnabledWhenProperty");
  }
}
 
bool EnabledWhenProperty::isVisible(const IPropertyManager *algo) const {
  // VisibleWhenProperty uses algo so we have to keep it to match interface
  UNUSED_ARG(algo);
  return true;
}
 
std::vector<std::string> EnabledWhenProperty::dependsOn(const std::string &thisProp) const {
  if (m_propertyDetails) {
    const std::string &otherProp = m_propertyDetails->otherPropName;
    if (otherProp == thisProp)
      throw std::runtime_error("EnabledWhenProperty: 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 *EnabledWhenProperty::clone() const { return new EnabledWhenProperty(*this); }
 
} // namespace Mantid::Kernel