IPropertyManager.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 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 +
#pragma once
 
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/IValidator.h"
#include "MantidKernel/NullValidator.h"
#include "MantidKernel/PropertyWithValue.h"
 
#ifndef Q_MOC_RUN
#include <memory>
#endif
 
#include <memory>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <unordered_set>
#include <vector>
 
namespace Json {
class Value;
}
 
namespace Mantid {
namespace Types {
namespace Core {
class DateAndTime;
}
} // namespace Types
namespace Kernel {
 
class DataItem;
class IPropertySettings;
class OptionalBool;
class Property;
class PropertyManager;
class SplittingInterval;
class LogFilter;
template <typename T> class TimeSeriesProperty;
template <typename T> class Matrix;
 
class MANTID_KERNEL_DLL IPropertyManager {
public:
  virtual ~IPropertyManager() = default;
 
  virtual void declareProperty(std::unique_ptr<Property> p, const std::string &doc = "") = 0;
 
  virtual void declareOrReplaceProperty(std::unique_ptr<Property> p, const std::string &doc = "") = 0;
 
  template <typename T>
  void declareProperty(const std::string &name, T value, IValidator_sptr validator = std::make_shared<NullValidator>(),
                       const std::string &doc = "", const unsigned int direction = Direction::Input) {
    std::unique_ptr<PropertyWithValue<T>> p = std::make_unique<PropertyWithValue<T>>(name, value, validator, direction);
    declareProperty(std::move(p), doc);
  }
 
  template <typename T>
  void declareProperty(const std::string &name, T value, const std::string &doc,
                       const unsigned int direction = Direction::Input) {
    std::unique_ptr<PropertyWithValue<T>> p =
        std::make_unique<PropertyWithValue<T>>(name, value, std::make_shared<NullValidator>(), direction);
    declareProperty(std::move(p), doc);
  }
 
  template <typename T> void declareProperty(const std::string &name, T value, const unsigned int direction) {
    std::unique_ptr<PropertyWithValue<T>> p =
        std::make_unique<PropertyWithValue<T>>(name, value, std::make_shared<NullValidator>(), direction);
    declareProperty(std::move(p));
  }
 
  void declareProperty(const std::string &name, const char *value,
                       IValidator_sptr validator = std::make_shared<NullValidator>(),
                       const std::string &doc = std::string(), const unsigned int direction = Direction::Input) {
    if (value == nullptr)
      throw std::invalid_argument("Attempted to set " + name + " to nullptr");
    // Simply call templated method, converting character array to a string
    declareProperty(name, std::string(value), std::move(validator), doc, direction);
  }
 
  void declareProperty(const std::string &name, const char *value, const std::string &doc,
                       IValidator_sptr validator = std::make_shared<NullValidator>(),
                       const unsigned int direction = Direction::Input) {
    if (value == nullptr)
      throw std::invalid_argument("Attempted to set " + name + " to nullptr");
    // Simply call templated method, converting character array to a string
    declareProperty(name, std::string(value), std::move(validator), doc, direction);
  }
 
  void declareProperty(const std::string &name, const char *value, const unsigned int direction) {
    if (value == nullptr)
      throw std::invalid_argument("Attempted to set " + name + " to nullptr");
 
    declareProperty(name, std::string(value), std::make_shared<NullValidator>(), "", direction);
  }
 
  virtual void removeProperty(const std::string &name, const bool delproperty = true) = 0;
 
  virtual std::unique_ptr<Property> takeProperty(const size_t index) = 0;
 
  virtual void resetProperties() = 0;
 
  virtual void setPropertiesWithString(
      const std::string &propertiesString,
      const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>()) = 0;
 
  virtual void
  setProperties(const std::string &propertiesJson,
                const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>(),
                bool createMissing = false) = 0;
 
  virtual void
  setProperties(const ::Json::Value &jsonValue,
                const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>(),
                bool createMissing = false) = 0;
 
  virtual void setPropertyValue(const std::string &name, const std::string &value) = 0;
 
  virtual void setPropertyValueFromJson(const std::string &name, const Json::Value &value) = 0;
 
  virtual void setPropertyOrdinal(const int &index, const std::string &value) = 0;
 
  virtual bool existsProperty(const std::string &name) const = 0;
 
  virtual bool validateProperties() const = 0;
  virtual size_t propertyCount() const = 0;
  virtual std::string getPropertyValue(const std::string &name) const = 0;
 
  virtual const std::vector<Property *> &getProperties() const = 0;
 
  virtual std::vector<std::string> getDeclaredPropertyNames() const noexcept = 0;
 
  template <typename T> IPropertyManager *setProperty(const std::string &name, const T &value) {
    return doSetProperty(name, value);
  }
 
  template <typename T> IPropertyManager *setProperty(const std::string &name, std::unique_ptr<T> value) {
    setTypedProperty(name, std::move(value), std::is_convertible<std::unique_ptr<T>, std::shared_ptr<DataItem>>());
    this->afterPropertySet(name);
    return this;
  }
 
  IPropertyManager *setProperty(const std::string &name, const char *value) {
    if (value == nullptr)
      throw std::invalid_argument("Attempted to set " + name + " to nullptr");
    return setProperty(name, std::string(value));
  }
 
  IPropertyManager *setProperty(const std::string &name, const std::string &value) {
    this->setPropertyValue(name, value);
    return this;
  }
 
  void updatePropertyValues(const IPropertyManager &other);
 
  virtual std::string asString(bool withDefaultValues = false) const = 0;
 
  virtual ::Json::Value asJson(bool withDefaultValues = false) const = 0;
 
  void setPropertySettings(const std::string &name, std::unique_ptr<IPropertySettings> settings);
 
  void setPropertyGroup(const std::string &name, const std::string &group) {
    Property *prop = getPointerToProperty(name);
    if (prop)
      prop->setGroup(group);
  }
 
  std::vector<Property *> getPropertiesInGroup(const std::string &group) const;
 
  virtual void filterByProperty(Mantid::Kernel::LogFilter * /*logFilter*/, const std::vector<std::string> &
                                /* excludedFromFiltering */) {
    throw std::logic_error("Not implemented yet.");
  }
 
protected:
  virtual Property *getPointerToPropertyOrdinal(const int &index) const = 0;
 
  template <typename T> T getValue(const std::string &name) const;
 
  virtual void clear() = 0;
  virtual void afterPropertySet(const std::string &) {}
 
  struct MANTID_KERNEL_DLL TypedValue {
    const IPropertyManager &pm;
    const std::string prop;
 
    TypedValue(const IPropertyManager &p, const std::string &name) : pm(p), prop(name) {}
 
    // Unfortunately, MSVS2010 can't handle just having a single templated cast
    // operator T()
    // (it has problems with the string one). This operator is needed to convert
    // a TypedValue
    // into what we actually want. It can't even handle just having a
    // specialization for strings.
    // So we have to explicitly define an operator for each type of property
    // that we have.
 
    operator int16_t();
    operator uint16_t();
    operator int32_t();
    operator uint32_t();
    operator int64_t();
    operator uint64_t();
    operator OptionalBool();
 
#ifdef __APPLE__
    operator unsigned long();
#endif
    operator bool();
    operator double();
    operator std::string();
    operator Property *();
 
    template <typename T> operator std::vector<T>() { return pm.getValue<std::vector<T>>(prop); }
    template <typename T> operator std::vector<std::vector<T>>() {
      return pm.getValue<std::vector<std::vector<T>>>(prop);
    }
    template <typename T> operator std::shared_ptr<T>() { return pm.getValue<std::shared_ptr<T>>(prop); }
    template <typename T> operator std::shared_ptr<const T>() { return pm.getValue<std::shared_ptr<T>>(prop); }
    template <typename T> operator Matrix<T>() { return pm.getValue<Matrix<T>>(prop); }
  };
 
public:
  virtual TypedValue getProperty(const std::string &name) const = 0;
  virtual Property *getPointerToProperty(const std::string &name) const = 0;
 
private:
  template <typename T> IPropertyManager *doSetProperty(const std::string &name, const T &value) {
    setTypedProperty(name, value, std::is_convertible<T, std::shared_ptr<DataItem>>());
    this->afterPropertySet(name);
    return this;
  }
 
  template <typename T> IPropertyManager *doSetProperty(const std::string &name, const std::shared_ptr<T> &value) {
    // CAREFUL: is_convertible has undefined behavior for incomplete types. If T
    // is forward-declared in the calling code, e.g., an algorithm that calls
    // setProperty, compilation and linking do work. However, the BEHAVIOR IS
    // UNDEFINED and the compiler will not complain, but things crash or go
    // wrong badly. To circumvent this we call `sizeof` here to force a compiler
    // error if T is an incomplete type.
    static_cast<void>(sizeof(T)); // DO NOT REMOVE, enforces complete type
    setTypedProperty(name, value, std::is_convertible<T *, DataItem *>());
    this->afterPropertySet(name);
    return this;
  }
 
  template <typename T>
  IPropertyManager *setTypedProperty(const std::string &name, const T &value, const std::false_type &) {
    PropertyWithValue<T> *prop = dynamic_cast<PropertyWithValue<T> *>(getPointerToProperty(name));
    if (prop) {
      *prop = value;
    } else {
      throw std::invalid_argument("Attempt to assign to property (" + name + ") of incorrect type");
    }
    return this;
  }
  template <typename T>
  IPropertyManager *setTypedProperty(const std::string &name, const T &value, const std::true_type &) {
    // T is convertible to DataItem_sptr
    std::shared_ptr<DataItem> data = std::static_pointer_cast<DataItem>(value);
    std::string error = getPointerToProperty(name)->setDataItem(data);
    if (!error.empty()) {
      throw std::invalid_argument(error);
    }
    return this;
  }
 
  template <typename T>
  IPropertyManager *setTypedProperty(const std::string &name, std::unique_ptr<T> value, const std::true_type &) {
    // T is convertible to DataItem_sptr
    std::shared_ptr<DataItem> data(std::move(value));
    std::string error = getPointerToProperty(name)->setDataItem(data);
    if (!error.empty()) {
      throw std::invalid_argument(error);
    }
    return this;
  }
};
 
} // namespace Kernel
} // namespace Mantid
 
#define DEFINE_IPROPERTYMANAGER_GETVALUE(type)                                                                         \
  namespace Mantid {                                                                                                   \
  namespace Kernel {                                                                                                   \
  template <> DLLExport type IPropertyManager::getValue<type>(const std::string &name) const {                         \
    PropertyWithValue<type> *prop = dynamic_cast<PropertyWithValue<type> *>(getPointerToProperty(name));               \
    if (prop) {                                                                                                        \
      return *prop;                                                                                                    \
    } else {                                                                                                           \
      std::string message = "Attempt to assign property " + name + " to incorrect type. Expected type " #type;         \
      throw std::runtime_error(message);                                                                               \
    }                                                                                                                  \
  }                                                                                                                    \
  }                                                                                                                    \
  }