Property.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 "MantidKernel/DllConfig.h"
#ifndef Q_MOC_RUN
#include <memory>
#endif
 
#include <set>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace NeXus {
class File;
}
 
namespace Json {
class Value;
}
namespace std {
class typeinfo;
}
 
namespace Mantid {
namespace Types {
namespace Core {
class DateAndTime;
}
} // namespace Types
namespace Kernel {
//-----------------------------------------------------------------------------
// Forward declarations
//-----------------------------------------------------------------------------
class DataItem;
class IPropertySettings;
class PropertyHistory;
class SplittingInterval;
 
struct Direction {
  enum Type {
    Input,  
    Output, 
    InOut,  
    None
  };
 
  static const std::string asText(const unsigned int &direction) {
    switch (direction) {
    case Input:
      return "Input";
    case Output:
      return "Output";
    case InOut:
      return "InOut";
    default:
      return "N/A";
    }
  }
 
  static int asEnum(const std::string &direction) {
    if (direction == "Input")
      return Direction::Input;
    else if (direction == "Output")
      return Direction::Output;
    else if (direction == "InOut")
      return Direction::InOut;
    else
      return Direction::None;
  }
};
 
class MANTID_KERNEL_DLL Property {
public:
  virtual Property *clone() const = 0;
  virtual ~Property();
 
  // Getters
  const std::string &name() const;
  const std::string &documentation() const;
  const std::type_info *type_info() const;
  const std::string type() const;
 
  virtual std::string isValid() const;
 
  void setSettings(std::unique_ptr<IPropertySettings> settings);
  IPropertySettings *getSettings();
  void clearSettings();
 
  virtual bool isDefault() const = 0;
  bool remember() const;
  void setRemember(bool);
 
  void setDocumentation(const std::string &documentation);
 
  virtual void saveProperty(::NeXus::File * /*file*/) {
    throw std::invalid_argument("Property::saveProperty - Cannot save '" + this->name() +
                                "', property type not implemented.");
  }
  virtual std::string value() const = 0;
  virtual std::string valueAsPrettyStr(const size_t maxLength = 0, const bool collapseLists = true) const;
  virtual Json::Value valueAsJson() const = 0;
  virtual bool isValueSerializable() const { return true; }
  virtual std::string setValue(const std::string &) = 0;
  virtual std::string setValueFromJson(const Json::Value &) = 0;
  virtual std::string setValueFromProperty(const Property &right) = 0;
  virtual std::string setDataItem(const std::shared_ptr<DataItem> &) = 0;
  virtual std::string getDefault() const = 0;
 
  virtual bool isMultipleSelectionAllowed() { return false; }
 
  virtual std::vector<std::string> allowedValues() const;
 
  virtual const PropertyHistory createHistory() const;
 
  void createTemporaryValue();
  bool hasTemporaryValue() const;
 
  unsigned int direction() const { return m_direction; }
 
  virtual Property &operator+=(Property const *rhs) = 0;
  virtual void filterByTime(const Types::Core::DateAndTime &start, const Types::Core::DateAndTime &stop);
  virtual void splitByTime(std::vector<SplittingInterval> &splitter, std::vector<Property *> outputs,
                           bool isProtonCharge = true) const;
 
  virtual int size() const;
 
  virtual const std::string &units() const;
 
  virtual void setUnits(const std::string &unit);
 
  virtual size_t getMemorySize() const { return sizeof(Property); }
 
  virtual Property &merge(Property *) { return *this; }
 
  void setGroup(const std::string &group) { m_group = group; }
 
  const std::string &getGroup() { return m_group; }
 
  bool autoTrim() const;
  void setAutoTrim(const bool &setting);
 
protected:
  Property(std::string name, const std::type_info &type, const unsigned int &direction = Direction::Input);
  Property(const Property &right);
  std::string m_name;
 
private:
  Property &operator=(const Property &right);
 
  std::string m_documentation;
  const std::type_info *m_typeinfo;
  const unsigned int m_direction;
  std::string m_units;
 
  std::unique_ptr<IPropertySettings> m_settings;
 
  std::string m_group;
 
  Property();
 
  bool m_remember;
 
  bool m_autotrim;
};
 
MANTID_KERNEL_DLL bool operator==(const Mantid::Kernel::Property &lhs, const Mantid::Kernel::Property &rhs);
MANTID_KERNEL_DLL bool operator!=(const Mantid::Kernel::Property &lhs, const Mantid::Kernel::Property &rhs);
 
MANTID_KERNEL_DLL std::string getUnmangledTypeName(const std::type_info &type);
 
} // namespace Kernel
} // namespace Mantid