Parameter.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
 
#include "MantidGeometry/DllConfig.h"
#include "MantidKernel/Quat.h"
#include "MantidKernel/V3D.h"
#include <iomanip>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <typeinfo>
#include <vector>
 
namespace Mantid {
 
namespace Kernel {
template <class C, class Base, typename... Args> class Instantiator;
}
 
namespace Geometry {
//--------------------------------------------------------------------------
// Forward declarations
//--------------------------------------------------------------------------
class Instrument;
class ParameterMap;
class ParameterInfo;
 
class MANTID_GEOMETRY_DLL Parameter {
public:
  virtual ~Parameter() = default;
 
  const std::string &type() const { return m_type; }
  const std::string &name() const { return m_name; }
  const char *nameAsCString() const { return m_name.c_str(); }
  const bool &visible() const { return m_visible; }
 
  virtual Parameter *clone() const = 0;
 
  virtual std::string asString() const { return m_str_value; }
 
  virtual void fromString(const std::string &value) { m_str_value = value; }
 
  template <class T> const T &value() const;
  virtual void setDescription(const std::string &source) { m_description.assign(source); }
  virtual const std::string &getDescription() const { return m_description; }
  virtual std::string getShortDescription() const;
  virtual void setVisible(const bool &visible) { m_visible = visible; }
  bool operator==(const Parameter &rhs) const {
    if (this->name() == rhs.name() && this->type() == rhs.type() && this->asString() == rhs.asString())
      return true;
    else
      return false;
  }
 
protected:
  friend class ParameterMap;
  friend class ParameterInfo;
  friend class Instrument;
 
  template <class T> void set(const T &t);
 
  friend class ParameterFactory;
  Parameter() : m_type(""), m_name(""), m_str_value(""), m_visible(true), m_description("") {}
 
private:
  std::string m_type;
  std::string m_name;
  std::string m_str_value; 
  bool m_visible;          
  std::string m_description;
};
 
template <class Type> class ParameterType : public Parameter {
public:
  ParameterType() : Parameter(), m_value() {}
 
  std::string asString() const override;
  void fromString(const std::string &value) override;
 
  inline const Type &value() const { return m_value; }
  inline const Type &operator()() const { return m_value; }
 
  Parameter *clone() const override { return new ParameterType(*this); }
 
private:
  friend class ParameterMap;
  friend class ComponentInfo;
  friend class Parameter;
  void setValue(const Type &value);
  ParameterType &operator=(const Type &value);
 
private:
  Type m_value; 
};
 
//--------------------------------------------------------------------------
// Template definitions - Parameter class
//--------------------------------------------------------------------------
 
template <class T> const T &Parameter::value() const {
  auto const *p = dynamic_cast<ParameterType<T> const *>(this);
  if (!p)
    throw std::runtime_error("Wrong type of parameter.");
  return p->ParameterType<T>::value();
}
 
template <class T> void Parameter::set(const T &t) {
  ParameterType<T> *p = dynamic_cast<ParameterType<T> *>(this);
  if (!p)
    throw std::runtime_error("Wrong type of parameter.");
  p->ParameterType<T>::setValue(t);
}
 
//--------------------------------------------------------------------------
// Template definitions - ParameterType class
//--------------------------------------------------------------------------
 
template <class Type> void ParameterType<Type>::fromString(const std::string &value) {
  if constexpr (std::is_same_v<Type, std::string>) {
    m_value = value;
  } else {
    std::istringstream istr(value);
    istr >> m_value;
  }
}
 
template <class Type> void ParameterType<Type>::setValue(const Type &value) { m_value = value; }
 
template <class Type> ParameterType<Type> &ParameterType<Type>::operator=(const Type &value) {
  setValue(value);
  return *this;
}
 
using Parameter_sptr = std::shared_ptr<Parameter>;
 
// Instantiated and exported by Parameter.cpp. FitParameter is declared in FitParameter.h.
MANTID_GEOMETRY_EXTERN_TEMPLATE(ParameterType<int>);
MANTID_GEOMETRY_EXTERN_TEMPLATE(ParameterType<double>);
MANTID_GEOMETRY_EXTERN_TEMPLATE(ParameterType<bool>);
MANTID_GEOMETRY_EXTERN_TEMPLATE(ParameterType<std::string>);
MANTID_GEOMETRY_EXTERN_TEMPLATE(ParameterType<Kernel::V3D>);
MANTID_GEOMETRY_EXTERN_TEMPLATE(ParameterType<Kernel::Quat>);
 
} // namespace Geometry
} // namespace Mantid