PropertyManagerOwner.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/PropertyManagerOwner.h"
#include "MantidKernel/Logger.h"
#include "MantidKernel/Property.h"
#include "MantidKernel/PropertyManager.h"
#include <algorithm>
#include <json/json.h>
 
namespace Mantid::Kernel {
namespace {
// Get a reference to the logger
Logger g_log("PropertyManagerOwner");
} // namespace
 
PropertyManagerOwner::PropertyManagerOwner() : m_properties(new PropertyManager) {}
 
PropertyManagerOwner::PropertyManagerOwner(const PropertyManagerOwner &po) : m_properties(po.m_properties) {}
 
PropertyManagerOwner &PropertyManagerOwner::operator=(const PropertyManagerOwner &po) {
  m_properties = po.m_properties;
  return *this;
}
 
void PropertyManagerOwner::declareProperty(std::unique_ptr<Property> p, const std::string &doc) {
  m_properties->declareProperty(std::move(p), doc);
}
 
void PropertyManagerOwner::declareOrReplaceProperty(std::unique_ptr<Property> p, const std::string &doc) {
  m_properties->declareOrReplaceProperty(std::move(p), doc);
}
 
void PropertyManagerOwner::resetProperties() { m_properties->resetProperties(); }
 
void PropertyManagerOwner::setProperties(const std::string &propertiesJson,
                                         const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  m_properties->setProperties(propertiesJson, this, ignoreProperties, createMissing);
}
 
void PropertyManagerOwner::setProperties(const ::Json::Value &jsonValue,
                                         const std::unordered_set<std::string> &ignoreProperties, bool createMissing) {
  m_properties->setProperties(jsonValue, this, ignoreProperties, createMissing);
}
 
void PropertyManagerOwner::setPropertiesWithString(const std::string &propertiesString,
                                                   const std::unordered_set<std::string> &ignoreProperties) {
  m_properties->setPropertiesWithString(propertiesString, ignoreProperties);
}
 
void PropertyManagerOwner::setPropertyValue(const std::string &name, const std::string &value) {
  m_properties->setPropertyValue(name, value);
  this->afterPropertySet(name);
}
 
void PropertyManagerOwner::setPropertyValueFromJson(const std::string &name, const Json::Value &value) {
  m_properties->setPropertyValueFromJson(name, value);
  this->afterPropertySet(name);
}
 
void PropertyManagerOwner::setPropertyOrdinal(const int &index, const std::string &value) {
  m_properties->setPropertyOrdinal(index, value);
  this->afterPropertySet(m_properties->getPointerToPropertyOrdinal(index)->name());
}
 
bool PropertyManagerOwner::existsProperty(const std::string &name) const { return m_properties->existsProperty(name); }
 
bool PropertyManagerOwner::validateProperties() const { return m_properties->validateProperties(); }
 
size_t PropertyManagerOwner::propertyCount() const { return m_properties->propertyCount(); }
 
std::string PropertyManagerOwner::getPropertyValue(const std::string &name) const {
  return m_properties->getPropertyValue(name);
}
 
Property *PropertyManagerOwner::getPointerToProperty(const std::string &name) const {
  return m_properties->getPointerToProperty(name);
}
 
Property *PropertyManagerOwner::getPointerToPropertyOrdinal(const int &index) const {
  return m_properties->getPointerToPropertyOrdinal(index);
}
 
const std::vector<Property *> &PropertyManagerOwner::getProperties() const { return m_properties->getProperties(); }
 
std::vector<std::string> PropertyManagerOwner::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;
}
 
IPropertyManager::TypedValue PropertyManagerOwner::getProperty(const std::string &name) const {
  return m_properties->getProperty(name);
}
 
bool PropertyManagerOwner::isDefault(const std::string &name) const {
  return m_properties->getPointerToProperty(name)->isDefault();
}
 
std::string PropertyManagerOwner::asString(bool withDefaultValues) const {
  return m_properties->asString(withDefaultValues);
}
::Json::Value PropertyManagerOwner::asJson(bool withDefaultValues) const {
  return m_properties->asJson(withDefaultValues);
}
 
void PropertyManagerOwner::removeProperty(const std::string &name, const bool delproperty) {
  m_properties->removeProperty(name, delproperty);
}
 
std::unique_ptr<Property> PropertyManagerOwner::takeProperty(const size_t index) {
  return m_properties->takeProperty(index);
}
 
void PropertyManagerOwner::clear() { m_properties->clear(); }
 
void PropertyManagerOwner::afterPropertySet(const std::string &name) { m_properties->afterPropertySet(name); }
 
} // namespace Mantid::Kernel