PropertyManager.h

Go to the documentation of this file.

// 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
 
//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include <map>
#include <vector>
 
#include "MantidKernel/IPropertyManager.h"
 
namespace Mantid {
namespace Kernel {
//----------------------------------------------------------------------
// Forward Declaration
//----------------------------------------------------------------------
class SplittingInterval;
template <typename T> class TimeSeriesProperty;
 
class MANTID_KERNEL_DLL PropertyManager : virtual public IPropertyManager {
public:
  static const std::string INVALID_VALUES_SUFFIX;
  // Gets the correct log name for the matching invalid values log for a given
  // log name
  static std::string getInvalidValuesFilterLogName(const std::string &logName);
  static std::string getLogNameFromInvalidValuesFilter(const std::string &logName);
  static bool isAnInvalidValuesFilterLog(const std::string &logName);
 
  PropertyManager();
  PropertyManager(const PropertyManager &);
  PropertyManager &operator=(const PropertyManager &);
  PropertyManager &operator+=(const PropertyManager &rhs);
 
  void filterByTime(const Types::Core::DateAndTime &start, const Types::Core::DateAndTime &stop) override;
  void splitByTime(std::vector<SplittingInterval> &splitter, std::vector<PropertyManager *> outputs) const override;
  void filterByProperty(const TimeSeriesProperty<bool> &filter,
                        const std::vector<std::string> &excludedFromFiltering = std::vector<std::string>()) override;
 
  virtual ~PropertyManager() override;
 
  // Function to declare properties (i.e. store them)
  void declareProperty(std::unique_ptr<Property> p, const std::string &doc = "") override;
  using IPropertyManager::declareProperty;
  void declareOrReplaceProperty(std::unique_ptr<Property> p, const std::string &doc = "") override;
  void resetProperties() override;
  // Sets all the declare properties
  void setProperties(const std::string &propertiesJson,
                     const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>(),
                     bool createMissing = false) override;
  void setProperties(const std::string &propertiesJson, IPropertyManager *targetPropertyManager,
                     const std::unordered_set<std::string> &ignoreProperties, bool createMissing = false);
  void setProperties(const ::Json::Value &jsonValue,
                     const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>(),
                     bool createMissing = false) override;
  void setProperties(const ::Json::Value &jsonValue, IPropertyManager *targetPropertyManager,
                     const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>(),
                     bool createMissing = false);
  void setPropertiesWithString(
      const std::string &propertiesString,
      const std::unordered_set<std::string> &ignoreProperties = std::unordered_set<std::string>()) override;
  void setPropertyValue(const std::string &name, const std::string &value) override;
  void setPropertyValueFromJson(const std::string &name, const Json::Value &value) override;
  void setPropertyOrdinal(const int &index, const std::string &value) override;
 
  bool existsProperty(const std::string &name) const override;
  bool validateProperties() const override;
  size_t propertyCount() const override;
  std::string getPropertyValue(const std::string &name) const override;
  const std::vector<Property *> &getProperties() const override;
  std::vector<std::string> getDeclaredPropertyNames() const noexcept override;
 
  void removeProperty(const std::string &name, const bool delproperty = true) override;
  std::unique_ptr<Property> takeProperty(const size_t index) override;
  void clear() override;
 
  TypedValue getProperty(const std::string &name) const override;
  std::string asString(bool withDefaultValues = false) const override;
  ::Json::Value asJson(bool withDefaultValues = false) const override;
 
  bool operator==(const PropertyManager &other) const;
  bool operator!=(const PropertyManager &other) const;
 
  Property *getPointerToProperty(const std::string &name) const override;
 
protected:
  friend class PropertyManagerOwner;
 
  Property *getPointerToPropertyOrdinal(const int &index) const override;
  Property *getPointerToPropertyOrNull(const std::string &name) const;
 
private:
  void setPropertiesWithSimpleString(const std::string &propertiesString,
                                     const std::unordered_set<std::string> &ignoreProperties);
  void setPropertiesWithJSONString(const std::string &propertiesString,
                                   const std::unordered_set<std::string> &ignoreProperties);
 
  using PropertyMap = std::map<std::string, std::unique_ptr<Property>>;
  PropertyMap m_properties;
  std::vector<Property *> m_orderedProperties;
};
 
using PropertyManager_sptr = std::shared_ptr<PropertyManager>;
 
MANTID_KERNEL_DLL ::Json::Value encodeAsJson(const PropertyManager &propMgr);
 
} // namespace Kernel
} // namespace Mantid