EnumeratedStringProperty.hxx

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 +
#pragma once
 
#include "MantidKernel/PropertyHelper.h"
#include "MantidKernel/PropertyWithValueJSON.h"
#include <json/value.h>
 
namespace Mantid::Kernel {
 
//------------------------------------------------------------------------------------------------
// Now the EnumeratedStringProperty class itself
//------------------------------------------------------------------------------------------------
 
// ######################################################//
//     CONSTRUCTORS
// ######################################################//
 
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names>::EnumeratedStringProperty(std::string const &name, ENUMSTRING const &defaultValue,
                                                             Direction::Type const direction)
    : Property(name, typeid(ENUMSTRING), direction), m_value(defaultValue), m_initialValue(std::move(defaultValue)) {}
 
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names>::EnumeratedStringProperty(EnumeratedStringProperty const &right)
    : Property(right), m_value(right.m_value), m_initialValue(right.m_initialValue) {
} // the default is the initial value of the original object
 
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names> *EnumeratedStringProperty<E, names>::clone() const {
  return new EnumeratedStringProperty<E, names>(*this);
}
 
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names> &
EnumeratedStringProperty<E, names>::operator=(EnumeratedStringProperty const &right) {
  if (&right == this)
    return *this;
  this->m_value = right.m_value;
  return *this;
}
 
// ######################################################//
//     GETTERS
// ######################################################//
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::value() const {
  return static_cast<std::string>(m_value);
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::valueAsPrettyStr(std::size_t const maxLength,
                                                                 bool const collapseLists) const {
  return toPrettyString(static_cast<std::string>(m_value), maxLength, collapseLists);
}
 
template <class E, std::vector<std::string> const *const names>
Json::Value EnumeratedStringProperty<E, names>::valueAsJson() const {
  return encodeAsJson((*this)());
}
 
template <class E, std::vector<std::string> const *const names>
bool EnumeratedStringProperty<E, names>::operator==(EnumeratedStringProperty const &rhs) const {
  if (this->name() != rhs.name())
    return false;
  return (static_cast<E>(this->m_value) == static_cast<E>(rhs.m_value));
}
 
template <class E, std::vector<std::string> const *const names>
bool EnumeratedStringProperty<E, names>::operator!=(EnumeratedStringProperty const &rhs) const {
  return !(*this == rhs);
}
 
template <class E, std::vector<std::string> const *const names> int EnumeratedStringProperty<E, names>::size() const {
  return 1;
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::getDefault() const {
  return static_cast<std::string>(m_initialValue);
}
 
template <class E, std::vector<std::string> const *const names>
EnumeratedString<E, names> EnumeratedStringProperty<E, names>::operator()() const {
  return m_value;
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::isValid() const {
  if (m_value.size() != 0)
    return "";
  else
    return "EnumeratedStringProperty was not set with valid EnumeratedString.\n";
}
 
template <class E, std::vector<std::string> const *const names>
bool EnumeratedStringProperty<E, names>::isDefault() const {
  return m_initialValue == m_value;
}
 
template <class E, std::vector<std::string> const *const names>
std::vector<std::string> EnumeratedStringProperty<E, names>::allowedValues() const {
  return *names;
}
 
// ######################################################//
//     SETTERS
// ######################################################//
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::setValue(E const value) {
  this->m_value = static_cast<EnumeratedString<E, names>>(value);
  return "";
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::setValue(std::string const &value) {
  try {
    this->m_value = static_cast<EnumeratedString<E, names>>(value);
  } catch (std::runtime_error &exc) {
    const std::string msg = exc.what();
    if (msg.empty())
      return "value \"" + value + "\" not in allowed list";
    else
      return msg;
  }
  return ""; // everything was fine
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::setValue(EnumeratedString<E, names> const &value) {
  this->m_value = value;
  return "";
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::setValueFromJson(Json::Value const &value) {
  if (value.type() != Json::stringValue) {
    try {
      *this = decode<E>(value);
    } catch (std::invalid_argument &exc) {
      return exc.what();
    }
    return "";
  } else {
    return setValue(value.asString());
  }
}
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::setDataItem(std::shared_ptr<DataItem> const &data) {
  // Pass of the helper function that is able to distinguish whether
  // the TYPE of the PropertyWithValue can be converted to a
  // shared_ptr<DataItem>
  return setTypedValue(data, std::is_convertible<EnumeratedString<E, names>, std::shared_ptr<DataItem>>());
}
 
//--------------------------------------------------------------------------------------
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names> const &EnumeratedStringProperty<E, names>::operator=(E const value) {
  this->m_value = static_cast<EnumeratedString<E, names>>(value);
  return *this;
}
 
//--------------------------------------------------------------------------------------
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names> const &EnumeratedStringProperty<E, names>::operator=(std::string const &value) {
  this->m_value = static_cast<EnumeratedString<E, names>>(value);
  return *this;
}
 
//--------------------------------------------------------------------------------------
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names> const &
EnumeratedStringProperty<E, names>::operator=(EnumeratedString<E, names> const &value) {
  this->m_value = value;
  return *this;
}
 
// ######################################################//
//     MUTATORS AND SUNDRY
// ######################################################//
 
//--------------------------------------------------------------------------------------
template <class E, std::vector<std::string> const *const names>
EnumeratedStringProperty<E, names> &EnumeratedStringProperty<E, names>::operator+=(Property const *right) {
  std::ostringstream oss;
  oss << "Cannot add EnumeratedStringProperty " << std::hex << std::showbase << reinterpret_cast<uintptr_t>(&right)
      << ", addition not implemented." << std::endl;
  throw std::invalid_argument(oss.str());
}
 
template <class E, std::vector<std::string> const *const names>
void EnumeratedStringProperty<E, names>::saveProperty(Nexus::File * /*file*/) {
  // AppleClang 7.3 and later gives a -Winfinite-recursion warning if I call the
  // base class method. The function is small enough that reimplementing it
  // isn't a big deal.
  throw std::invalid_argument("PropertyWithValue::saveProperty - Cannot save '" + this->name() + "', property type " +
                              typeid(ENUMSTRING).name() + " not implemented.");
}
 
// ######################################################//
//     PRIVATE METHODS
// ######################################################//
 
template <class E, std::vector<std::string> const *const names>
std::string EnumeratedStringProperty<E, names>::setValueFromProperty(Property const &right) {
 
  if (auto prop = dynamic_cast<EnumeratedStringProperty<E, names> const *>(&right)) {
    this->m_value = prop->m_value;
    return "";
  } else {
    return setValue(right.value());
  }
}
 
template <class E, std::vector<std::string> const *const names>
template <typename U>
std::string EnumeratedStringProperty<E, names>::setTypedValue(U const &value, std::true_type const &) {
  std::string msg;
  try {
    m_value = EnumeratedString<E, names>(value);
  } catch (std::runtime_error &exc) {
    msg = exc.what();
  }
  return msg;
}
 
template <class E, std::vector<std::string> const *const names>
template <typename U>
std::string EnumeratedStringProperty<E, names>::setTypedValue(U const &, std::false_type const &) {
  return "Attempt to assign object of type DataItem to property (" + name() + ") of incorrect type";
}
 
} // namespace Mantid::Kernel