Property.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 +
#include "MantidKernel/Property.h"
 
#include "MantidKernel/DateAndTime.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/IPropertySettings.h"
#include "MantidKernel/OptionalBool.h"
#include "MantidKernel/PropertyHistory.h"
#include "MantidKernel/Strings.h"
#include "MantidKernel/TimeSeriesProperty.h"
 
#include <unordered_map>
 
namespace Mantid {
namespace Kernel {
 
Property::Property(std::string name, const std::type_info &type, const unsigned int &direction)
    : m_name(std::move(name)), m_documentation(""), m_typeinfo(&type), m_direction(direction), m_units(""), m_group(""),
      m_remember(true), m_autotrim(true) {
  if (m_name.empty()) {
    throw std::invalid_argument("An empty property name is not permitted");
  }
 
  // Make sure a random int hasn't been passed in for the direction
  // Property & PropertyWithValue destructors will be called in this case
  if (m_direction > 2)
    throw std::out_of_range("direction should be a member of the Direction enum");
}
 
Property::Property(const Property &right)
    : m_name(right.m_name), m_documentation(right.m_documentation), m_typeinfo(right.m_typeinfo),
      m_direction(right.m_direction), m_units(right.m_units), m_group(right.m_group), m_remember(right.m_remember),
      m_autotrim(right.m_autotrim) {
  if (m_name.empty()) {
    throw std::invalid_argument("An empty property name is not permitted");
  }
  if (right.m_settings)
    m_settings.reset(right.m_settings->clone());
}
 
Property::~Property() = default;
 
const std::string &Property::name() const { return m_name; }
 
const std::string &Property::documentation() const { return m_documentation; }
 
const std::type_info *Property::type_info() const { return m_typeinfo; }
 
const std::string Property::type() const { return Mantid::Kernel::getUnmangledTypeName(*m_typeinfo); }
 
std::string Property::isValid() const {
  // the no error condition
  return "";
}
 
void Property::setSettings(std::unique_ptr<IPropertySettings> settings) { m_settings = std::move(settings); }
 
IPropertySettings *Property::getSettings() { return m_settings.get(); }
 
void Property::clearSettings() { m_settings.reset(nullptr); }
 
bool Property::remember() const { return m_remember; }
 
void Property::setRemember(bool remember) { m_remember = remember; }
 
std::string Property::valueAsPrettyStr(const size_t maxLength, const bool collapseLists) const {
  UNUSED_ARG(collapseLists);
  return Strings::shorten(value(), maxLength);
}
 
void Property::setDocumentation(const std::string &documentation) { m_documentation = documentation; }
 
std::vector<std::string> Property::allowedValues() const { return std::vector<std::string>(); }
 
const PropertyHistory Property::createHistory() const { return PropertyHistory(this); }
 
void Property::createTemporaryValue() {
  std::ostringstream os;
  os << "__TMP" << this;
  this->setValue(os.str());
}
 
bool Property::hasTemporaryValue() const {
  std::ostringstream os;
  os << "__TMP" << this;
  return (os.str() == this->value());
}
 
//-------------------------------------------------------------------------------------------------
int Property::size() const { return 1; }
 
//-------------------------------------------------------------------------------------------------
const std::string &Property::units() const { return m_units; }
 
//-------------------------------------------------------------------------------------------------
void Property::setUnits(const std::string &unit) { m_units = unit; }
 
//-------------------------------------------------------------------------------------------------
void Property::filterByTime(const Types::Core::DateAndTime &start, const Types::Core::DateAndTime &stop) {
  UNUSED_ARG(start);
  UNUSED_ARG(stop);
  // Do nothing in general
}
 
//-----------------------------------------------------------------------------------------------
void Property::splitByTime(std::vector<SplittingInterval> &splitter, std::vector<Property *> outputs,
                           bool isProtonCharge) const {
  UNUSED_ARG(splitter);
  UNUSED_ARG(outputs);
  UNUSED_ARG(isProtonCharge);
}
 
} // namespace Kernel
 
//-------------------------- Utility function for class name lookup
//-----------------------------
 
// MG 16/07/09: Some forward declarations.I need this so
// that the typeid function in getUnmangledTypeName knows about them
// This way I don't need to actually include the headers and I don't
// introduce unwanted dependencies
namespace API {
class Workspace;
class WorkspaceGroup;
class MatrixWorkspace;
class ITableWorkspace;
class IMDEventWorkspace;
class IMDWorkspace;
class IEventWorkspace;
class IPeaksWorkspace;
class IMDHistoWorkspace;
class IFunction;
class IAlgorithm;
} // namespace API
namespace DataObjects {
class EventWorkspace;
class PeaksWorkspace;
class LeanElasticPeaksWorkspace;
class GroupingWorkspace;
class OffsetsWorkspace;
class MaskWorkspace;
class SpecialWorkspace2D;
class Workspace2D;
class TableWorkspace;
class SpecialWorkspace2D;
class SplittersWorkspace;
} // namespace DataObjects
 
namespace Kernel {
class PropertyManager;
 
bool operator==(const Property &lhs, const Property &rhs) {
  if (lhs.name() != rhs.name())
    return false;
  if (lhs.type() != rhs.type())
    return false;
 
  // check for TimeSeriesProperty specializations
  auto lhs_tsp_float = dynamic_cast<const TimeSeriesProperty<float> *>(&lhs);
  if (lhs_tsp_float)
    return lhs_tsp_float->operator==(rhs);
 
  auto lhs_tsp_double = dynamic_cast<const TimeSeriesProperty<double> *>(&lhs);
  if (lhs_tsp_double)
    return lhs_tsp_double->operator==(rhs);
 
  auto lhs_tsp_string = dynamic_cast<const TimeSeriesProperty<std::string> *>(&lhs);
  if (lhs_tsp_string)
    return lhs_tsp_string->operator==(rhs);
 
  auto lhs_tsp_bool = dynamic_cast<const TimeSeriesProperty<bool> *>(&lhs);
  if (lhs_tsp_bool)
    return lhs_tsp_bool->operator==(rhs);
 
  // use fallthrough behavior
  return (lhs.value() == rhs.value());
}
 
bool operator!=(const Property &lhs, const Property &rhs) { return (!(lhs == rhs)); }
 
std::string getUnmangledTypeName(const std::type_info &type) {
  using std::make_pair;
  using std::string;
  using namespace Mantid::API;
  using namespace Mantid::DataObjects;
  // Compile a lookup table. This is a static local variable that
  // will get initialized when the function is first used
  static std::unordered_map<string, string> typestrings;
  if (typestrings.empty()) {
    typestrings.emplace(typeid(char).name(), string("letter"));
    typestrings.emplace(typeid(int).name(), string("number"));
    typestrings.emplace(typeid(long long).name(), string("number"));
    typestrings.emplace(typeid(int64_t).name(), string("number"));
    typestrings.emplace(typeid(double).name(), string("number"));
    typestrings.emplace(typeid(bool).name(), string("boolean"));
    typestrings.emplace(typeid(string).name(), string("string"));
    typestrings.emplace(typeid(std::vector<string>).name(), string("str list"));
    typestrings.emplace(typeid(std::vector<int>).name(), string("int list"));
    typestrings.emplace(typeid(std::vector<long>).name(), string("long list"));
    typestrings.emplace(typeid(std::vector<int64_t>).name(), string("int list"));
    typestrings.emplace(typeid(std::vector<size_t>).name(), string("unsigned int list"));
    typestrings.emplace(typeid(std::vector<double>).name(), string("dbl list"));
    typestrings.emplace(typeid(std::vector<std::vector<string>>).name(), string("list of str lists"));
    typestrings.emplace(typeid(OptionalBool).name(), string("optional boolean"));
 
    // Workspaces
    typestrings.emplace(typeid(std::shared_ptr<Workspace>).name(), string("Workspace"));
    typestrings.emplace(typeid(std::shared_ptr<MatrixWorkspace>).name(), string("MatrixWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<ITableWorkspace>).name(), string("TableWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<IMDWorkspace>).name(), string("IMDWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<IMDEventWorkspace>).name(), string("MDEventWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<IEventWorkspace>).name(), string("IEventWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<Workspace2D>).name(), string("Workspace2D"));
    typestrings.emplace(typeid(std::shared_ptr<EventWorkspace>).name(), string("EventWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<PeaksWorkspace>).name(), string("PeaksWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<LeanElasticPeaksWorkspace>).name(), string("LeanElasticPeaksWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<IPeaksWorkspace>).name(), string("IPeaksWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<GroupingWorkspace>).name(), string("GroupingWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<WorkspaceGroup>).name(), string("WorkspaceGroup"));
    typestrings.emplace(typeid(std::shared_ptr<OffsetsWorkspace>).name(), string("OffsetsWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<MaskWorkspace>).name(), string("MaskWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<SpecialWorkspace2D>).name(), string("SpecialWorkspace2D"));
    typestrings.emplace(typeid(std::shared_ptr<IMDHistoWorkspace>).name(), string("IMDHistoWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<SplittersWorkspace>).name(), string("SplittersWorkspace"));
    typestrings.emplace(typeid(std::shared_ptr<SpecialWorkspace2D>).name(), string("SpecialWorkspace2D"));
    typestrings.emplace(typeid(std::shared_ptr<TableWorkspace>).name(), string("TableWorkspace"));
    // FunctionProperty
    typestrings.emplace(typeid(std::shared_ptr<IFunction>).name(), string("Function"));
    typestrings.emplace(typeid(std::shared_ptr<IAlgorithm>).name(), string("IAlgorithm"));
    typestrings.emplace(typeid(std::shared_ptr<PropertyManager>).name(), string("Dictionary"));
  }
  auto mitr = typestrings.find(type.name());
  if (mitr != typestrings.end()) {
    return mitr->second;
  }
 
  return type.name();
}
 
bool Property::autoTrim() const { return m_autotrim; }
 
void Property::setAutoTrim(const bool &setting) { m_autotrim = setting; }
} // namespace Kernel
 
} // namespace Mantid