PropertyWithValue.hxx

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/PropertyWithValue.h"
 
#include "MantidKernel/Exception.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/NullValidator.h"
#include "MantidKernel/OptionalBool.h"
#include "MantidKernel/PropertyHelper.h"
#include "MantidKernel/PropertyWithValueJSON.h"
#include "MantidKernel/Strings.h"
 
#ifndef Q_MOC_RUN
#include <boost/algorithm/string/trim.hpp>
#include <memory>
#endif
 
#include "MantidKernel/IPropertySettings.h"
#include "MantidKernel/StringTokenizer.h"
#include "MantidNexus/NexusFile.h"
#include <json/value.h>
#include <type_traits>
#include <vector>
 
namespace Mantid {
namespace Kernel {
 
//------------------------------------------------------------------------------------------------
// Now the PropertyWithValue class itself
//------------------------------------------------------------------------------------------------
 
template <typename TYPE>
PropertyWithValue<TYPE>::PropertyWithValue(std::string name, TYPE defaultValue, IValidator_sptr validator,
                                           unsigned int direction)
    : Property(std::move(name), typeid(TYPE), direction), m_value(defaultValue),
      m_initialValue(std::move(defaultValue)),
      m_validator(validator ? std::move(validator) : std::make_shared<NullValidator>()) {}
 
template <typename TYPE>
PropertyWithValue<TYPE>::PropertyWithValue(std::string name, TYPE defaultValue, unsigned int direction)
    : Property(std::move(name), typeid(TYPE), direction), m_value(defaultValue),
      m_initialValue(std::move(defaultValue)), m_validator(std::make_shared<NullValidator>()) {}
 
/*
  Constructor to handle vector value assignments to m_initialValue
  so they can be remembered when the algorithm dialog is reloaded.
*/
template <typename TYPE>
PropertyWithValue<TYPE>::PropertyWithValue(const std::string &name, const TYPE &defaultValue,
                                           const std::string &defaultValueStr, IValidator_sptr validator,
                                           unsigned int direction)
    : Property(name, typeid(TYPE), direction), m_value(extractToValueVector<TYPE>(defaultValueStr)),
      m_initialValue(m_value), m_validator(validator ? std::move(validator) : std::make_shared<NullValidator>()) {
  UNUSED_ARG(defaultValue);
}
 
template <typename TYPE>
PropertyWithValue<TYPE>::PropertyWithValue(const PropertyWithValue<TYPE> &right)
    : Property(right), m_value(right.m_value), m_initialValue(right.m_initialValue), // the default is the initial
                                                                                     // value of the original object
      m_validator(right.m_validator->clone()) {}
 
template <typename TYPE> PropertyWithValue<TYPE> *PropertyWithValue<TYPE>::clone() const {
  return new PropertyWithValue<TYPE>(*this);
}
 
template <typename TYPE> void PropertyWithValue<TYPE>::saveProperty(Nexus::File *file) {
  if constexpr (std::is_same_v<TYPE, float> || std::is_same_v<TYPE, double> || std::is_same_v<TYPE, int32_t> ||
                std::is_same_v<TYPE, uint32_t> || std::is_same_v<TYPE, int64_t> || std::is_same_v<TYPE, uint64_t> ||
                std::is_same_v<TYPE, long> || std::is_same_v<TYPE, std::string> ||
                std::is_same_v<TYPE, std::vector<double>> || std::is_same_v<TYPE, std::vector<int32_t>>) {
    file->makeGroup(this->name(), "NXlog", true);
    file->writeData("value", m_value);
    file->openData("value");
    file->putAttr("units", this->units());
    file->closeData();
    file->closeGroup();
  } else {
    // AppleClang 7.3 and later gives a -Winfinite-recursion warning if I call the
    // base class method. The function is small enough that reimplementing it
    // isn't a big deal.
    throw std::invalid_argument("PropertyWithValue::saveProperty - Cannot save '" + this->name() + "', property type " +
                                typeid(TYPE).name() + " not implemented.");
  }
}
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::value() const { return toString(m_value); }
 
template <typename TYPE>
std::string PropertyWithValue<TYPE>::valueAsPrettyStr(const size_t maxLength, const bool collapseLists) const {
  std::string retVal;
  try {
    retVal = toPrettyString(m_value, maxLength, collapseLists);
  } catch (boost::bad_lexical_cast &) {
    // toPrettyStringFailed, default to using toString instead
    retVal = Strings::shorten(value(), maxLength);
  }
  return retVal;
}
 
template <typename TYPE> Json::Value PropertyWithValue<TYPE>::valueAsJson() const { return encodeAsJson((*this)()); }
 
template <typename TYPE> bool PropertyWithValue<TYPE>::operator==(const PropertyWithValue<TYPE> &rhs) const {
  if (this->name() != rhs.name())
    return false;
  return (m_value == rhs.m_value);
}
 
template <typename TYPE> bool PropertyWithValue<TYPE>::operator!=(const PropertyWithValue<TYPE> &rhs) const {
  return !(*this == rhs);
}
 
template <typename TYPE> int PropertyWithValue<TYPE>::size() const { return findSize(m_value); }
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::getDefault() const { return toString(m_initialValue); }
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::setValue(const std::string &value) {
  try {
    TYPE result = m_value;
    std::string valueCopy = value;
    if (autoTrim()) {
      boost::trim(valueCopy);
    }
    toValue(valueCopy, result);
    // Uses the assignment operator defined below which runs isValid() and
    // throws based on the result
    *this = result;
    return "";
  } catch (boost::bad_lexical_cast &) {
    std::string error = "Could not set property " + name() + ". Can not convert \"" + value + "\" to " + type();
    g_logger.debug() << error;
    return error;
  } catch (std::invalid_argument &except) {
    g_logger.debug() << "Could not set property " << name() << ": " << except.what();
    return except.what();
  }
}
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::setValueFromJson(const Json::Value &value) {
  if (value.type() != Json::stringValue) {
    try {
      *this = decode<TYPE>(value);
    } catch (std::invalid_argument &exc) {
      return exc.what();
    }
    return "";
  } else {
    return setValue(value.asString());
  }
}
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::setDataItem(const std::shared_ptr<DataItem> &data) {
  // Pass of the helper function that is able to distinguish whether
  // the TYPE of the PropertyWithValue can be converted to a
  // shared_ptr<DataItem>
  return setTypedValue(data, std::is_convertible<TYPE, std::shared_ptr<DataItem>>());
}
 
// cppcheck-suppress operatorEqVarError
template <typename TYPE> PropertyWithValue<TYPE> &PropertyWithValue<TYPE>::operator=(const PropertyWithValue &right) {
  if (&right == this)
    return *this;
  m_value = right.m_value;
  m_validator = right.m_validator->clone();
  return *this;
}
 
//--------------------------------------------------------------------------------------
template <typename TYPE> PropertyWithValue<TYPE> &PropertyWithValue<TYPE>::operator+=(Property const *right) {
  PropertyWithValue const *rhs = dynamic_cast<PropertyWithValue const *>(right);
 
  if (rhs) {
    // This function basically does:
    //  m_value += rhs->m_value; for values
    //  or concatenates vectors for vectors
    addingOperator(m_value, rhs->m_value);
  } else
    g_logger.warning() << "PropertyWithValue " << this->name()
                       << " could not be added to another property of the "
                          "same name but incompatible type.\n";
 
  return *this;
}
 
//--------------------------------------------------------------------------------------
template <typename TYPE> PropertyWithValue<TYPE> &PropertyWithValue<TYPE>::operator=(const TYPE &value) {
  TYPE oldValue = m_value;
  if constexpr (std::is_same<TYPE, std::string>::value) {
    std::string valueCopy = toString(value);
    if (autoTrim()) {
      boost::trim(valueCopy);
    }
    toValue(valueCopy, m_value);
  } else {
    m_value = value;
  }
  std::string problem = this->isValid();
  if (problem.empty()) {
    return *this;
  } else if (problem == "_alias") {
    m_value = getValueForAlias(value);
    return *this;
  } else {
    m_value = oldValue;
    throw std::invalid_argument("When setting value of property \"" + this->name() + "\": " + problem);
  }
}
 
template <typename TYPE> const TYPE &PropertyWithValue<TYPE>::operator()() const { return m_value; }
 
template <typename TYPE> PropertyWithValue<TYPE>::operator const TYPE &() const { return m_value; }
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::isValid() const { return m_validator->isValid(m_value); }
 
template <typename TYPE> bool PropertyWithValue<TYPE>::isDefault() const { return m_initialValue == m_value; }
 
template <typename TYPE> std::vector<std::string> PropertyWithValue<TYPE>::allowedValues() const {
  return determineAllowedValues(m_value, *m_validator);
}
 
template <typename TYPE> bool PropertyWithValue<TYPE>::isMultipleSelectionAllowed() {
  return m_validator->isMultipleSelectionAllowed();
}
 
template <typename TYPE> void PropertyWithValue<TYPE>::replaceValidator(IValidator_sptr newValidator) {
  m_validator = newValidator;
}
 
template <typename TYPE> std::string PropertyWithValue<TYPE>::setValueFromProperty(const Property &right) {
 
  if (auto prop = dynamic_cast<const PropertyWithValue<TYPE> *>(&right)) {
    m_value = prop->m_value;
    return "";
  } else {
    return setValue(right.value());
  }
}
 
template <typename TYPE>
template <typename U>
std::string PropertyWithValue<TYPE>::setTypedValue(const U &value, const std::true_type &) {
  TYPE data = std::dynamic_pointer_cast<typename TYPE::element_type>(value);
  std::string msg;
  if (data) {
    try {
      (*this) = data;
    } catch (std::invalid_argument &exc) {
      msg = exc.what();
    }
  } else {
    msg = "Invalid DataItem. The object type (" + std::string(typeid(value).name()) +
          ") does not match the declared type of the property (" + std::string(this->type()) + ").";
  }
  return msg;
}
 
template <typename TYPE>
template <typename U>
std::string PropertyWithValue<TYPE>::setTypedValue(const U &value, const std::false_type &) {
  UNUSED_ARG(value);
  return "Attempt to assign object of type DataItem to property (" + name() + ") of incorrect type";
}
 
template <typename TYPE> const TYPE PropertyWithValue<TYPE>::getValueForAlias(const TYPE &alias) const {
  std::string strAlias = toString(alias);
  std::string strValue = m_validator->getValueForAlias(strAlias);
  TYPE typeValue;
  toValue(strValue, typeValue);
  return typeValue;
}
 
template <typename TYPE> IValidator_sptr PropertyWithValue<TYPE>::getValidator() const { return m_validator; }
 
} // namespace Kernel
} // namespace Mantid