RegisterWorkspacePtrToPython.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2014 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/Workspace.h"
#include "MantidPythonInterface/core/WeakPtr.h"
#include "MantidPythonInterface/kernel/Registry/TypeRegistry.h"
#include "MantidPythonInterface/kernel/Registry/TypedPropertyValueHandler.h"
 
#include <boost/python/register_ptr_to_python.hpp>
 
namespace Mantid::PythonInterface::Registry {
 
// Specialization for shared_ptr<Workspace> and derived types.
template <typename T>
struct DLLExport TypedPropertyValueHandler<std::shared_ptr<T>,
                                           typename std::enable_if<std::is_base_of<API::Workspace, T>::value>::type>
    : public PropertyValueHandler {
  using HeldType = std::shared_ptr<T>;
 
  using PointeeType = T;
  using PropertyValueType = std::shared_ptr<T>;
 
  void set(Kernel::IPropertyManager *alg, const std::string &name, const boost::python::object &value) const override {
    if (value == boost::python::object())
      alg->setProperty<HeldType>(name, std::shared_ptr<T>(nullptr));
    else
      alg->setProperty<HeldType>(name, std::dynamic_pointer_cast<T>(ExtractSharedPtr<API::Workspace>(value)()));
  }
 
  std::unique_ptr<Kernel::Property> create(const std::string &name, const boost::python::object &defaultValue,
                                           const boost::python::object &validator,
                                           const unsigned int direction) const override {
    using boost::python::extract;
    using Kernel::IValidator;
    using Kernel::Property;
    using Kernel::PropertyWithValue;
    const PropertyValueType valueInC = extract<PropertyValueType>(defaultValue)();
    std::unique_ptr<Property> valueProp;
    if (isNone(validator)) {
      valueProp = std::make_unique<PropertyWithValue<PropertyValueType>>(name, valueInC, direction);
    } else {
      const IValidator *propValidator = extract<IValidator *>(validator);
      valueProp =
          std::make_unique<PropertyWithValue<PropertyValueType>>(name, valueInC, propValidator->clone(), direction);
    }
    return valueProp;
  }
};
 
template <typename IType> struct DLLExport RegisterWorkspacePtrToPython {
  using IType_sptr = std::shared_ptr<IType>;
  using IType_wptr = std::weak_ptr<IType>;
  RegisterWorkspacePtrToPython() {
    using namespace boost::python;
    using namespace Registry;
 
    register_ptr_to_python<IType_sptr>();
    register_ptr_to_python<IType_wptr>();
    // properties can only ever store pointers to these
    TypeRegistry::subscribe<TypedPropertyValueHandler<IType_sptr>>();
  }
};
} // namespace Mantid::PythonInterface::Registry