BoostOptionalToAlgorithmProperty.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2016 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 "MantidAPI/Algorithm.h"
#include "MantidAPI/DllConfig.h"
#include "MantidGeometry/Instrument.h"
#include "MantidGeometry/Instrument/ComponentInfo.h"
#include <boost/lexical_cast.hpp>
#include <optional>
#include <string>
#include <type_traits>
 
namespace Mantid {
namespace API {
template <typename T>
T checkForMandatoryInstrumentDefault(const Mantid::API::Algorithm *const alg, const std::string &propName,
                                     const Mantid::Geometry::Instrument_const_sptr &instrument,
                                     const std::string &idf_name) {
  const auto *algProperty = alg->getPointerToProperty(propName);
  if (algProperty->isDefault()) {
    auto defaults = instrument->getNumberParameter(idf_name);
    if (defaults.empty()) {
      throw std::runtime_error("No data could be retrieved from the parameters "
                               "and argument wasn't provided: " +
                               propName);
    }
    return static_cast<T>(defaults[0]);
  } else {
    return static_cast<T>(boost::lexical_cast<double, std::string>(algProperty->value()));
  }
}
 
template <typename T>
std::optional<T> checkForOptionalInstrumentDefault(const Mantid::API::Algorithm *const alg, const std::string &propName,
                                                   const Mantid::Geometry::Instrument_const_sptr &instrument,
                                                   const std::string &idf_name) {
  const auto *algProperty = alg->getPointerToProperty(propName);
  if (algProperty->isDefault()) {
    auto defaults = instrument->getNumberParameter(idf_name);
    if (!defaults.empty()) {
      return std::optional<T>(static_cast<T>(defaults[0]));
    } else {
      return std::nullopt;
    }
  } else {
    double value = boost::lexical_cast<double, std::string>(algProperty->value());
    return std::optional<T>(static_cast<T>(value));
  }
}
 
template <typename T>
T checkForMandatoryInstrumentDefault(Mantid::API::Algorithm const *const alg, std::string const &propName,
                                     Mantid::Geometry::ComponentInfo const &componentInfo,
                                     std::string const &idf_name) {
  auto const *algProperty = alg->getPointerToProperty(propName);
  if constexpr (std::is_same_v<T, std::string>) {
    if (!algProperty->isDefault()) {
      return algProperty->value();
    }
    auto const defaults = componentInfo.getStringParameter(componentInfo.root(), idf_name);
    if (defaults.empty()) {
      throw std::runtime_error("No data could be retrieved from the parameters "
                               "and argument wasn't provided: " +
                               propName);
    }
    return defaults[0];
  } else {
    if (!algProperty->isDefault()) {
      return static_cast<T>(boost::lexical_cast<double, std::string>(algProperty->value()));
    }
    auto const defaults = componentInfo.getNumberParameter(componentInfo.root(), idf_name);
    if (defaults.empty()) {
      throw std::runtime_error("No data could be retrieved from the parameters "
                               "and argument wasn't provided: " +
                               propName);
    }
    return static_cast<T>(defaults[0]);
  }
}
 
template <typename T>
std::optional<T> checkForOptionalInstrumentDefault(Mantid::API::Algorithm const *const alg, std::string const &propName,
                                                   Mantid::Geometry::ComponentInfo const &componentInfo,
                                                   std::string const &idf_name) {
  auto const *algProperty = alg->getPointerToProperty(propName);
  if constexpr (std::is_same_v<T, std::string>) {
    if (!algProperty->isDefault()) {
      return algProperty->value();
    }
    auto const defaults = componentInfo.getStringParameter(componentInfo.root(), idf_name);
    if (defaults.empty()) {
      return std::nullopt;
    }
    return defaults[0];
  } else {
    if (!algProperty->isDefault()) {
      return static_cast<T>(boost::lexical_cast<double, std::string>(algProperty->value()));
    }
    auto const defaults = componentInfo.getNumberParameter(componentInfo.root(), idf_name);
    if (defaults.empty()) {
      return std::nullopt;
    }
    return static_cast<T>(defaults[0]);
  }
}
 
template <>
MANTID_API_DLL std::string checkForMandatoryInstrumentDefault(const Mantid::API::Algorithm *const alg,
                                                              const std::string &propName,
                                                              const Mantid::Geometry::Instrument_const_sptr &instrument,
                                                              const std::string &idf_name);
 
template <>
MANTID_API_DLL std::optional<std::string>
checkForOptionalInstrumentDefault(const Mantid::API::Algorithm *const alg, const std::string &propName,
                                  const Mantid::Geometry::Instrument_const_sptr &instrument,
                                  const std::string &idf_name);
} // namespace API
} // namespace Mantid