FunctionProperty.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 "MantidAPI/FunctionProperty.h"
#include "MantidAPI/FunctionFactory.h"
#include "MantidKernel/PropertyHistory.h"
 
#include <json/value.h>
 
namespace Mantid::API {
FunctionProperty::FunctionProperty(const std::string &name, const unsigned int direction,
                                   const PropertyMode::Type optional)
    : Kernel::PropertyWithValue<std::shared_ptr<IFunction>>(name, std::shared_ptr<IFunction>(),
                                                            std::make_shared<Kernel::NullValidator>(), direction),
      m_optional(optional) {}
 
FunctionProperty &FunctionProperty::operator=(const std::shared_ptr<IFunction> &value) {
  Kernel::PropertyWithValue<std::shared_ptr<IFunction>>::operator=(value);
  return *this;
}
 
//--------------------------------------------------------------------------------------
FunctionProperty &FunctionProperty::operator+=(Kernel::Property const * /*right*/) {
  throw Kernel::Exception::NotImplementedError("+= operator is not implemented for FunctionProperty.");
}
 
std::string FunctionProperty::value() const {
  if (m_value)
    return m_value->asString();
  else
    return getDefault();
}
 
Json::Value FunctionProperty::valueAsJson() const { return Json::Value(value()); }
 
std::string FunctionProperty::getDefault() const { return ""; }
 
bool FunctionProperty::isOptional() const { return (m_optional == PropertyMode::Optional); }
 
std::string FunctionProperty::setValue(const std::string &value) {
  std::string error;
 
  if (isOptional() && value.empty()) {
    // No error message when the function string is empty and the function is optional
    m_value = std::shared_ptr<IFunction>();
    m_definition = value;
    return error;
  }
 
  try {
    m_value = std::shared_ptr<IFunction>(FunctionFactory::Instance().createInitialized(value));
    m_definition = value;
  } catch (std::exception &e) {
    error = e.what();
  }
  return error;
}
 
std::string FunctionProperty::setValueFromJson(const Json::Value &value) {
  try {
    return setValue(value.asString());
  } catch (std::exception &exc) {
    return exc.what();
  }
}
 
std::string FunctionProperty::isValid() const {
  if (isOptional() || direction() == Kernel::Direction::Output) {
    return "";
  } else {
    return isDefault() ? "Function is empty." : "";
  }
}
 
bool FunctionProperty::isDefault() const { return m_value == std::shared_ptr<IFunction>(); }
 
const Kernel::PropertyHistory FunctionProperty::createHistory() const { return Kernel::PropertyHistory(this); }
 
} // namespace Mantid::API