PropertyManager.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 +
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/PropertyManager.h"
#include "MantidJson/Json.h"
#include "MantidKernel/FilteredTimeSeriesProperty.h"
#include "MantidKernel/IPropertySettings.h"
#include "MantidKernel/LogFilter.h"
#include "MantidKernel/PropertyWithValueJSON.h"
#include "MantidKernel/StringTokenizer.h"
 
#include <json/json.h>
 
namespace Mantid::Kernel {
 
using std::string;
 
namespace {
// static logger reference
Logger g_log("PropertyManager");
 
const std::string createKey(const std::string &name) {
  std::string key = name;
  std::transform(key.begin(), key.end(), key.begin(), toupper);
  return key;
}
} // namespace
 
const std::string PropertyManager::INVALID_VALUES_SUFFIX = "_invalid_values";
std::string PropertyManager::getInvalidValuesFilterLogName(const std::string &logName) {
  return logName + PropertyManager::INVALID_VALUES_SUFFIX;
}
std::string PropertyManager::getLogNameFromInvalidValuesFilter(const std::string &logName) {
  std::string retVal = "";
  if (PropertyManager::isAnInvalidValuesFilterLog(logName)) {
    retVal = logName.substr(0, logName.size() - PropertyManager::INVALID_VALUES_SUFFIX.size());
  }
  return retVal;
}
bool PropertyManager::isAnInvalidValuesFilterLog(const std::string &logName) {
  const auto ending = PropertyManager::INVALID_VALUES_SUFFIX;
  if (logName.length() >= ending.length()) {
    return (0 == logName.compare(logName.length() - ending.length(), ending.length(), ending));
  } else {
    return false;
  }
}
//-----------------------------------------------------------------------------------------------
PropertyManager::PropertyManager() : m_properties(), m_orderedProperties() {}
 
//-----------------------------------------------------------------------------------------------
PropertyManager::PropertyManager(const PropertyManager &other)
    : m_properties(), m_orderedProperties(other.m_orderedProperties.size()) {
  // We need to do a deep copy of the property pointers here
  for (unsigned int i = 0; i < m_orderedProperties.size(); ++i) {
    auto p = std::unique_ptr<Property>(other.m_orderedProperties[i]->clone());
    this->m_orderedProperties[i] = p.get();
    this->m_properties[createKey(p->name())] = std::move(p);
  }
}
 
//-----------------------------------------------------------------------------------------------
PropertyManager &PropertyManager::operator=(const PropertyManager &other) {
  // We need to do a deep copy here
  if (this != &other) {
    this->m_properties.clear();
    this->m_orderedProperties.resize(other.m_orderedProperties.size());
    for (unsigned int i = 0; i < m_orderedProperties.size(); ++i) {
      auto p = std::unique_ptr<Property>(other.m_orderedProperties[i]->clone());
      this->m_orderedProperties[i] = p.get();
      this->m_properties[createKey(p->name())] = std::move(p);
    }
  }
  return *this;
}
 
//-----------------------------------------------------------------------------------------------
PropertyManager::~PropertyManager() { clear(); }
 
//-----------------------------------------------------------------------------------------------
PropertyManager &PropertyManager::operator+=(const PropertyManager &rhs) {
  // Iterate through all properties on the RHS
  PropertyMap::const_iterator it;
  for (it = rhs.m_properties.begin(); it != rhs.m_properties.end(); ++it) {
    // The name on the rhs
    string rhs_name = it->first;
    try {
      Property *lhs_prop = this->getPointerToProperty(rhs_name);
      // Use the property's += operator to add THAT. Isn't abstraction fun?!
      (*lhs_prop) += it->second.get();
    } catch (Exception::NotFoundError &) {
      // The property isnt on the lhs.
      // Let's copy it
      auto copy = std::unique_ptr<Property>(it->second->clone());
      // And we add a copy of that property to *this
      this->declareProperty(std::move(copy), "");
    }
  }
 
  return *this;
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::filterByTime(const Types::Core::DateAndTime &start, const Types::Core::DateAndTime &stop) {
  // Iterate through all properties
  PropertyMap::const_iterator it;
  for (it = this->m_properties.begin(); it != this->m_properties.end(); ++it) {
    // Filter out the property
    auto prop = it->second.get();
    prop->filterByTime(start, stop);
  }
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::splitByTime(std::vector<SplittingInterval> &splitter,
                                  std::vector<PropertyManager *> outputs) const {
  size_t n = outputs.size();
 
  // Iterate through all properties
  PropertyMap::const_iterator it;
  for (it = this->m_properties.begin(); it != this->m_properties.end(); ++it) {
    // Filter out the property
    Property *prop = it->second.get();
 
    // Make a vector of the output properties contained in the other property
    // managers.
    //  NULL if it was not found.
    std::vector<Property *> output_properties;
    for (size_t i = 0; i < n; i++) {
      if (outputs[i])
        output_properties.emplace_back(outputs[i]->getPointerToPropertyOrNull(prop->name()));
      else
        output_properties.emplace_back(nullptr);
    }
 
    // Now the property does the splitting.
    bool isProtonCharge = prop->name() == "proton_charge";
    prop->splitByTime(splitter, output_properties, isProtonCharge);
 
  } // for each property
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::filterByProperty(const Kernel::TimeSeriesProperty<bool> &filter,
                                       const std::vector<std::string> &excludedFromFiltering) {
  for (auto &orderedProperty : m_orderedProperties) {
    if (std::find(excludedFromFiltering.cbegin(), excludedFromFiltering.cend(), orderedProperty->name()) !=
        excludedFromFiltering.cend()) {
      // this log should be excluded from filtering
      continue;
    }
 
    Property *currentProp = orderedProperty;
    if (auto doubleSeries = dynamic_cast<TimeSeriesProperty<double> *>(currentProp)) {
      // don't filter the invalid values filters
      if (PropertyManager::isAnInvalidValuesFilterLog(currentProp->name()))
        break;
      std::unique_ptr<Property> filtered(nullptr);
      if (this->existsProperty(PropertyManager::getInvalidValuesFilterLogName(currentProp->name()))) {
        // add the filter to the passed in filters
        auto logFilter = std::make_unique<LogFilter>(filter);
        auto filterProp = getPointerToProperty(PropertyManager::getInvalidValuesFilterLogName(currentProp->name()));
        auto tspFilterProp = dynamic_cast<TimeSeriesProperty<bool> *>(filterProp);
        if (!tspFilterProp)
          break;
        logFilter->addFilter(*tspFilterProp);
 
        filtered = std::make_unique<FilteredTimeSeriesProperty<double>>(doubleSeries, *logFilter->filter());
      } else {
        filtered = std::make_unique<FilteredTimeSeriesProperty<double>>(doubleSeries, filter);
      }
      orderedProperty = filtered.get();
      // Now replace in the map
      this->m_properties[createKey(currentProp->name())] = std::move(filtered);
    }
  }
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::declareProperty(std::unique_ptr<Property> p, const std::string &doc) {
  p->setDocumentation(doc);
 
  const std::string key = createKey(p->name());
  auto existing = m_properties.find(key);
  if (existing == m_properties.end()) {
    m_orderedProperties.emplace_back(p.get());
    m_properties[key] = std::move(p);
  } else {
    // Don't error if this is actually the same property object!
    if (existing->second != p) {
      throw Exception::ExistsError("Property with given name already exists", key);
    }
  }
}
 
void PropertyManager::declareOrReplaceProperty(std::unique_ptr<Property> p, const std::string &doc) {
  p->setDocumentation(doc);
 
  const std::string key = createKey(p->name());
  auto existing = m_properties.find(key);
  if (existing != std::end(m_properties)) {
    // replace it in the same position
    auto oldPropPtr = existing->second.get();
    auto ordereredPropPos = std::find(std::begin(m_orderedProperties), std::end(m_orderedProperties), oldPropPtr);
    // if the property exists it should be guaranteed to be in the ordered list
    // by declareProperty
    assert(ordereredPropPos != std::end(m_orderedProperties));
    *ordereredPropPos = p.get();
  } else {
    m_orderedProperties.emplace_back(p.get());
  }
  m_properties[key] = std::move(p);
}
 
void PropertyManager::resetProperties() {
  for (auto &prop : getProperties()) {
    if (!prop->isDefault())
      prop->setValue(prop->getDefault());
  }
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::setProperties(const std::string &propertiesJson,
                                    const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  setProperties(propertiesJson, this, ignoreProperties, createMissing);
}
//-----------------------------------------------------------------------------------------------
void PropertyManager::setProperties(const std::string &propertiesJson, IPropertyManager *targetPropertyManager,
                                    const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  ::Json::Value jsonValue;
 
  if (Mantid::JsonHelpers::parse(propertiesJson, &jsonValue)) {
    setProperties(jsonValue, targetPropertyManager, ignoreProperties, createMissing);
  } else {
    throw std::invalid_argument("propertiesArray was not valid json");
  }
}
//-----------------------------------------------------------------------------------------------
void PropertyManager::setProperties(const ::Json::Value &jsonValue,
                                    const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  setProperties(jsonValue, this, ignoreProperties, createMissing);
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::setProperties(const ::Json::Value &jsonValue, IPropertyManager *targetPropertyManager,
                                    const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  if (jsonValue.type() != ::Json::ValueType::objectValue)
    return;
 
  // Some algorithms require Filename to be set first do that here
  static const std::string propFilename = "Filename";
  const ::Json::Value &filenameValue = jsonValue[propFilename];
  if (!filenameValue.isNull()) {
    const std::string value = filenameValue.asString();
    // Set it
    targetPropertyManager->setPropertyValue(propFilename, value);
  }
  const auto memberNames = jsonValue.getMemberNames();
  for (::Json::ArrayIndex i = 0; i < jsonValue.size(); i++) {
    const auto &propName = memberNames[i];
    if ((propFilename == propName) || (ignoreProperties.find(propName) != ignoreProperties.end())) {
      continue;
    }
    const ::Json::Value &propValue = jsonValue[propName];
    if (createMissing) {
      targetPropertyManager->declareOrReplaceProperty(decodeAsProperty(propName, propValue));
    } else {
      targetPropertyManager->setPropertyValueFromJson(propName, propValue);
    }
  }
}
 
void PropertyManager::setPropertiesWithString(const std::string &propertiesString,
                                              const std::unordered_set<std::string> &ignoreProperties) {
  if (propertiesString.empty()) {
    return;
  }
  auto firstSymbol = propertiesString.find_first_not_of(" \n\t");
  if (firstSymbol == std::string::npos) {
    return;
  }
  if (propertiesString[firstSymbol] == '{') {
    setPropertiesWithJSONString(propertiesString, ignoreProperties);
  } else {
    setPropertiesWithSimpleString(propertiesString, ignoreProperties);
  }
}
 
void PropertyManager::setPropertiesWithJSONString(const std::string &propertiesString,
                                                  const std::unordered_set<std::string> &ignoreProperties) {
  ::Json::Value propertyJson;
 
  if (Mantid::JsonHelpers::parse(propertiesString, &propertyJson)) {
    setProperties(propertyJson, ignoreProperties);
  } else {
    throw std::invalid_argument("Could not parse JSON string when trying to set a property from: " + propertiesString);
  }
}
 
void PropertyManager::setPropertiesWithSimpleString(const std::string &propertiesString,
                                                    const std::unordered_set<std::string> &ignoreProperties) {
  ::Json::Value propertyJson;
  // Split up comma-separated properties
  using tokenizer = Mantid::Kernel::StringTokenizer;
 
  boost::char_separator<char> sep(";");
  tokenizer propPairs(propertiesString, ";", Mantid::Kernel::StringTokenizer::TOK_TRIM);
  // Iterate over the properties
  for (const auto &pair : propPairs) {
    size_t n = pair.find('=');
    if (n != std::string::npos) {
      // Normal "PropertyName=value" string.
      std::string propName;
      std::string value;
 
      // Extract the value string
      if (n < pair.size() - 1) {
        propName = pair.substr(0, n);
        value = pair.substr(n + 1, pair.size() - n - 1);
      } else {
        // String is "PropertyName="
        propName = pair.substr(0, n);
        value = "";
      }
      // Set it
      propertyJson[propName] = value;
    }
  }
  setProperties(propertyJson, ignoreProperties);
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::setPropertyValue(const std::string &name, const std::string &value) {
  auto *prop = getPointerToProperty(name);
  auto helpMsg = prop->setValue(value);
  afterPropertySet(name);
  if (!helpMsg.empty()) {
    helpMsg = "Invalid value for property " + prop->name() + " (" + prop->type() + ") from string \"" + value +
              "\": " + helpMsg;
    throw std::invalid_argument(helpMsg);
  }
}
 
void PropertyManager::setPropertyValueFromJson(const std::string &name, const Json::Value &value) {
  auto *prop = getPointerToProperty(name);
  auto helpMsg = prop->setValueFromJson(value);
  afterPropertySet(name);
  if (!helpMsg.empty()) {
    helpMsg = "Invalid value for property " + prop->name() + " (" + prop->type() + ") from Json \"" +
              value.toStyledString() + "\": " + helpMsg;
    throw std::invalid_argument(helpMsg);
  }
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::setPropertyOrdinal(const int &index, const std::string &value) {
  Property *p = getPointerToPropertyOrdinal(index); // throws runtime_error if property not in vector
  std::string errorMsg = p->setValue(value);
  this->afterPropertySet(p->name());
  if (!errorMsg.empty()) {
    errorMsg = "Invalid value for property " + p->name() + " (" + p->type() + ") \"" + value + "\" : " + errorMsg;
    throw std::invalid_argument(errorMsg);
  }
}
 
//-----------------------------------------------------------------------------------------------
bool PropertyManager::existsProperty(const std::string &name) const {
  const std::string key = createKey(name);
  auto it = m_properties.find(key);
  return (it != m_properties.end());
}
 
//-----------------------------------------------------------------------------------------------
bool PropertyManager::validateProperties() const {
  bool allValid = true;
  for (const auto &property : m_properties) {
    // check for errors in each property
    std::string error = property.second->isValid();
    //"" means no error
    if (!error.empty()) {
      g_log.error() << "Property \"" << property.first << "\" is not set to a valid value: \"" << error << "\".\n";
      allValid = false;
    }
  }
  return allValid;
}
 
//-----------------------------------------------------------------------------------------------
size_t PropertyManager::propertyCount() const { return m_orderedProperties.size(); }
 
//-----------------------------------------------------------------------------------------------
std::string PropertyManager::getPropertyValue(const std::string &name) const {
  Property *p = getPointerToProperty(name); // throws NotFoundError if property not in vector
  return p->value();
}
 
//-----------------------------------------------------------------------------------------------
std::string PropertyManager::asString(bool withDefaultValues) const {
  Json::StreamWriterBuilder builder;
  builder.settings_["indentation"] = "";
  const string output = Json::writeString(builder, asJson(withDefaultValues));
 
  return output;
}
 
//-----------------------------------------------------------------------------------------------
::Json::Value PropertyManager::asJson(bool withDefaultValues) const {
  ::Json::Value jsonMap;
  const auto count = static_cast<int>(propertyCount());
  for (int i = 0; i < count; ++i) {
    Property *p = getPointerToPropertyOrdinal(i);
    bool is_enabled = true;
    if (p->getSettings()) {
      is_enabled = p->getSettings()->isEnabled(this);
    }
    if (p->isValueSerializable() && (withDefaultValues || !p->isDefault()) && is_enabled) {
      jsonMap[p->name()] = p->valueAsJson();
    }
  }
 
  return jsonMap;
}
 
bool PropertyManager::operator==(const PropertyManager &other) const {
  if (other.m_properties.size() != m_properties.size())
    return false;
  for (const auto &[key, value] : m_properties) {
    if (other.m_properties.count(key) != 1)
      return false;
    if (*other.m_properties.at(key) != *value)
      return false;
  }
  return true;
}
 
bool PropertyManager::operator!=(const PropertyManager &other) const { return !this->operator==(other); }
 
//-----------------------------------------------------------------------------------------------
Property *PropertyManager::getPointerToProperty(const std::string &name) const {
  const std::string key = createKey(name);
  auto it = m_properties.find(key);
  if (it != m_properties.end()) {
    return it->second.get();
  }
  throw Exception::NotFoundError("Unknown property", name);
}
 
//-----------------------------------------------------------------------------------------------
Property *PropertyManager::getPointerToPropertyOrNull(const std::string &name) const {
  const std::string key = createKey(name);
  auto it = m_properties.find(key);
  if (it != m_properties.end()) {
    return it->second.get();
  }
  return nullptr;
}
 
//-----------------------------------------------------------------------------------------------
Property *PropertyManager::getPointerToPropertyOrdinal(const int &index) const {
 
  if (index < static_cast<int>(m_orderedProperties.size())) {
    return m_orderedProperties[index];
  }
  throw std::runtime_error("Property index too high");
}
 
//-----------------------------------------------------------------------------------------------
const std::vector<Property *> &PropertyManager::getProperties() const { return m_orderedProperties; }
 
//-----------------------------------------------------------------------------------------------
std::vector<std::string> PropertyManager::getDeclaredPropertyNames() const noexcept {
  std::vector<std::string> names;
  const auto &props = getProperties();
  names.reserve(props.size());
  std::transform(props.cbegin(), props.cend(), std::back_inserter(names),
                 [](auto &propPtr) { return propPtr->name(); });
  return names;
}
 
//-----------------------------------------------------------------------------------------------
PropertyManager::TypedValue PropertyManager::getProperty(const std::string &name) const {
  return TypedValue(*this, name);
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::removeProperty(const std::string &name, const bool delproperty) {
  if (existsProperty(name)) {
    // remove it
    Property *prop = getPointerToProperty(name);
    const std::string key = createKey(name);
    m_properties.erase(key);
    std::vector<Property *>::iterator itr;
    itr = find(m_orderedProperties.begin(), m_orderedProperties.end(), prop);
    m_orderedProperties.erase(itr);
    (void)delproperty; // not used
  }
}
 
std::unique_ptr<Property> PropertyManager::takeProperty(const size_t index) {
  try {
    auto property = m_orderedProperties[index];
    const std::string key = createKey(property->name());
    auto propertyPtr = std::move(m_properties[key]);
    m_properties.erase(key);
    m_orderedProperties.erase(m_orderedProperties.cbegin() + index);
    return propertyPtr;
  } catch (const std::out_of_range &) {
    return NULL;
  }
}
 
//-----------------------------------------------------------------------------------------------
void PropertyManager::clear() {
  m_orderedProperties.clear();
  m_properties.clear();
}
 
//-----------------------------------------------------------------------------------------------
Json::Value encodeAsJson(const PropertyManager &propMgr) { return propMgr.asJson(true); }
 
} // namespace Mantid::Kernel