IPropertyManager.cpp

//----------------------------------------------------------------------
// Includes
//----------------------------------------------------------------------
#include "MantidKernel/IPropertyManager.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/System.h"
#include <algorithm>

///@cond
DEFINE_IPROPERTYMANAGER_GETVALUE(int16_t);
DEFINE_IPROPERTYMANAGER_GETVALUE(uint16_t);
DEFINE_IPROPERTYMANAGER_GETVALUE(int32_t);
DEFINE_IPROPERTYMANAGER_GETVALUE(uint32_t);
DEFINE_IPROPERTYMANAGER_GETVALUE(int64_t);
DEFINE_IPROPERTYMANAGER_GETVALUE(uint64_t);
DEFINE_IPROPERTYMANAGER_GETVALUE(bool);
DEFINE_IPROPERTYMANAGER_GETVALUE(double);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<int16_t>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<uint16_t>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<int32_t>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<uint32_t>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<int64_t>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<uint64_t>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<double>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<std::string>);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<std::vector<std::string>>);

namespace Mantid {
namespace Kernel {
// This template implementation has been left in because although you can't
// assign to an existing string
// via the getProperty() method, you can construct a local variable by saying,
// e.g.: std::string s = getProperty("myProperty")
template <>
DLLExport std::string
IPropertyManager::getValue<std::string>(const std::string &name) const {
  return getPropertyValue(name);
}

template <>
DLLExport Property *
IPropertyManager::getValue<Property *>(const std::string &name) const {
  return getPointerToProperty(name);
}

// If a string is given in the argument, we can be more flexible
template <>
IPropertyManager *
IPropertyManager::setProperty<std::string>(const std::string &name,
                                           const std::string &value) {
  this->setPropertyValue(name, value);
  return this;
}

/**
 * @param name The name of the property being looked for.
 * @return True if the property is managed by this.
 */
bool IPropertyManager::existsProperty(const std::string &name) const {
  auto props = this->getProperties();
  for (std::vector<Property *>::const_iterator prop = props.begin();
       prop != props.end(); ++prop) {
    if (name == (*prop)->name())
      return true;
  }
  return false;
}

/**
 * Set values of the properties existing in this manager to the values of
 * properties with the same name in another manger.
 * @param other A property manager to copy property values from.
 */
void IPropertyManager::updatePropertyValues(const IPropertyManager &other) {
  auto props = this->getProperties();
  for (auto prop = props.begin(); prop != props.end(); ++prop) {
    const std::string propName = (**prop).name();
    if (other.existsProperty(propName)) {
      (**prop).setValueFromProperty(*other.getPointerToProperty(propName));
    }
  }
}

/**
 * Get all properties in a group.
 * @param group Name of a group.
 */
std::vector<Property *>
IPropertyManager::getPropertiesInGroup(const std::string &group) const {
  auto props = getProperties();
  for (auto prop = props.begin(); prop != props.end();) {
    if ((**prop).getGroup() == group) {
      ++prop;
    } else {
      prop = props.erase(prop);
    }
  }
  return props;
}

// Definitions for TypedValue cast operators
// Have to come after getValue definitions above to keep MSVS2010 happy
IPropertyManager::TypedValue::operator int16_t() {
  return pm.getValue<int16_t>(prop);
}
IPropertyManager::TypedValue::operator uint16_t() {
  return pm.getValue<uint16_t>(prop);
}
IPropertyManager::TypedValue::operator int32_t() {
  return pm.getValue<int32_t>(prop);
}
IPropertyManager::TypedValue::operator uint32_t() {
  return pm.getValue<uint32_t>(prop);
}
IPropertyManager::TypedValue::operator int64_t() {
  return pm.getValue<int64_t>(prop);
}
IPropertyManager::TypedValue::operator uint64_t() {
  return pm.getValue<uint64_t>(prop);
}
IPropertyManager::TypedValue::operator bool() {
  return pm.getValue<bool>(prop);
}
IPropertyManager::TypedValue::operator double() {
  return pm.getValue<double>(prop);
}
IPropertyManager::TypedValue::operator std::string() {
  return pm.getPropertyValue(prop);
}
IPropertyManager::TypedValue::operator Property *() {
  return pm.getPointerToProperty(prop);
}

#ifdef __APPLE__
} // namespace Kernel
} // namespace Mantid
// These must precede the operator() declaration
DEFINE_IPROPERTYMANAGER_GETVALUE(unsigned long);
DEFINE_IPROPERTYMANAGER_GETVALUE(std::vector<unsigned long>);
namespace Mantid {
namespace Kernel {
// Intel 64-bit size_t
IPropertyManager::TypedValue::operator unsigned long() {
  return pm.getValue<unsigned long>(prop);
}
} // namespace Kernel
} // namespace Mantid

#else
} // namespace Kernel
} // namespace Mantid
#endif

/// @endcond