variant.hpp

//
// Copyright (c) 2024 INRIA
//

#ifndef __eigenpy_utils_variant_hpp__
#define __eigenpy_utils_variant_hpp__

#include "eigenpy/fwd.hpp"
#include "eigenpy/utils/traits.hpp"
#include "eigenpy/utils/python-compat.hpp"

#include <boost/python.hpp>
#include <boost/variant.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/vector.hpp>

#include <type_traits>

#ifdef EIGENPY_WITH_CXX17_SUPPORT
#include <variant>
#endif

namespace eigenpy {

namespace details {

template <typename ResultType, typename Variant>
struct VariantVisitorType {};

template <typename Variant>
struct VariantAlternatives {};

template <typename Variant>
struct empty_variant {};

template <typename T>
struct is_empty_variant : std::false_type {};

#ifdef EIGENPY_WITH_CXX17_SUPPORT

template <typename ResultType, typename... Alternatives>
struct VariantVisitorType<ResultType, std::variant<Alternatives...>> {
 typedef std::variant<Alternatives...> variant_type;
 typedef ResultType result_type;

 template <typename Visitor, typename Visitable>
 static result_type visit(Visitor&& visitor, Visitable&& v) {
 return std::visit(std::forward<Visitor>(visitor),
 std::forward<Visitable>(v));
 }

 result_type operator()(std::monostate) const {
 return bp::incref(bp::object().ptr()); // None
 }
};

template <typename... Alternatives>
struct VariantAlternatives<std::variant<Alternatives...>> {
 typedef boost::mpl::vector<Alternatives...> types;
};

template <typename... Alternatives>
struct empty_variant<std::variant<Alternatives...>> {
 typedef std::monostate type;
};

template <>
struct is_empty_variant<std::monostate> : std::true_type {};

#endif

template <typename ResultType, typename... Alternatives>
struct VariantVisitorType<ResultType, boost::variant<Alternatives...>>
 : boost::static_visitor<ResultType> {
 typedef boost::variant<Alternatives...> variant_type;
 typedef ResultType result_type;

 template <typename Visitor, typename Visitable>
 static result_type visit(Visitor&& visitor, Visitable&& visitable) {
 return std::forward<Visitable>(visitable).apply_visitor(visitor);
 }

 result_type operator()(boost::blank) const {
 return bp::incref(bp::object().ptr()); // None
 }
};

template <typename... Alternatives>
struct VariantAlternatives<boost::variant<Alternatives...>> {
 typedef typename boost::variant<Alternatives...>::types types;
};

template <typename... Alternatives>
struct empty_variant<boost::variant<Alternatives...>> {
 typedef boost::blank type;
};

template <>
struct is_empty_variant<boost::blank> : std::true_type {};

template <typename Variant>
struct EmptyConvertible {
 static void registration() {
 bp::converter::registry::push_back(convertible, construct,
 bp::type_id<Variant>());
 }

 // convertible only for None
 static void* convertible(PyObject* obj) {
 return (obj == Py_None) ? obj : nullptr;
 };

 // construct in place
 static void construct(PyObject*,
 bp::converter::rvalue_from_python_stage1_data* data) {
 void* storage =
 reinterpret_cast<bp::converter::rvalue_from_python_storage<Variant>*>(
 data)
 ->storage.bytes;
 new (storage) Variant(typename empty_variant<Variant>::type());
 data->convertible = storage;
 };
};

template <typename T, class Enable = void>
struct NumericConvertibleImpl {};

template <typename T>
struct NumericConvertibleImpl<
 T, typename std::enable_if<std::is_same<T, bool>::value>::type> {
 static void* convertible(PyObject* obj) {
 return PyBool_Check(obj) ? obj : nullptr;
 }

 static PyTypeObject const* expected_pytype() { return &PyBool_Type; }
};

template <typename T>
struct NumericConvertibleImpl<
 T, typename std::enable_if<!std::is_same<T, bool>::value &&
 std::is_integral<T>::value>::type> {
 static void* convertible(PyObject* obj) {
 // PyLong return true for bool type
 return (PyInt_Check(obj) && !PyBool_Check(obj)) ? obj : nullptr;
 }

 static PyTypeObject const* expected_pytype() { return &PyLong_Type; }
};

template <typename T>
struct NumericConvertibleImpl<
 T, typename std::enable_if<std::is_floating_point<T>::value>::type> {
 static void* convertible(PyObject* obj) {
 return PyFloat_Check(obj) ? obj : nullptr;
 }

 static PyTypeObject const* expected_pytype() { return &PyFloat_Type; }
};

template <typename T, typename Variant>
struct NumericConvertible {
 static void registration() {
 bp::converter::registry::push_back(
 &convertible, &bp::converter::implicit<T, Variant>::construct,
 bp::type_id<Variant>()
#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
 ,
 &expected_pytype
#endif
 );
 }

 static void* convertible(PyObject* obj) {
 return NumericConvertibleImpl<T>::convertible(obj);
 }
 static PyTypeObject const* expected_pytype() {
 return NumericConvertibleImpl<T>::expected_pytype();
 }
};

template <typename Variant>
struct VariantValueToObject : VariantVisitorType<PyObject*, Variant> {
 typedef VariantVisitorType<PyObject*, Variant> Base;
 typedef typename Base::result_type result_type;
 typedef typename Base::variant_type variant_type;

 static result_type convert(const variant_type& v) {
 return Base::visit(VariantValueToObject(), v);
 }

 template <typename T>
 result_type operator()(T& t) const {
 return bp::incref(bp::object(t).ptr());
 }

 using Base::operator();
};

template <typename Variant>
struct VariantRefToObject : VariantVisitorType<PyObject*, Variant> {
 typedef VariantVisitorType<PyObject*, Variant> Base;
 typedef typename Base::result_type result_type;
 typedef typename Base::variant_type variant_type;

 static result_type convert(const variant_type& v) {
 return Base::visit(VariantRefToObject(), v);
 }

 template <typename T,
 typename std::enable_if<is_python_primitive_type<T>::value,
 bool>::type = true>
 result_type operator()(T t) const {
 return bp::incref(bp::object(t).ptr());
 }

 template <typename T,
 typename std::enable_if<!is_python_primitive_type<T>::value,
 bool>::type = true>
 result_type operator()(T& t) const {
 return bp::detail::make_reference_holder::execute(&t);
 }

 using Base::operator();
};

template <typename Variant>
struct VariantConverter {
 typedef Variant variant_type;

 template <class T>
 struct apply {
 struct type {
 PyObject* operator()(const variant_type& v) const {
 return VariantRefToObject<variant_type>::convert(v);
 }

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES
 PyTypeObject const* get_pytype() const {
 return bp::converter::registered_pytype<variant_type>::get_pytype();
 }
#endif
 };
 };
};

template <typename Variant>
struct VariantConvertible {
 typedef Variant variant_type;

 template <class T, typename std::enable_if<is_empty_variant<T>::value,
 bool>::type = true>
 void operator()(T) {
 EmptyConvertible<variant_type>::registration();
 }

 template <class T, typename std::enable_if<!is_empty_variant<T>::value &&
 std::is_arithmetic<T>::value,
 bool>::type = true>
 void operator()(T) {
 NumericConvertible<T, variant_type>::registration();
 }

 template <class T, typename std::enable_if<!is_empty_variant<T>::value &&
 !std::is_arithmetic<T>::value,
 bool>::type = true>
 void operator()(T) {
 bp::implicitly_convertible<T, variant_type>();
 }
};

} // namespace details

template <typename Variant>
struct ReturnInternalVariant : bp::return_internal_reference<> {
 typedef Variant variant_type;

 typedef details::VariantConverter<variant_type> result_converter;

 template <class ArgumentPackage>
 static PyObject* postcall(ArgumentPackage const& args_, PyObject* result) {
 // Don't run return_internal_reference postcall on primitive type
 if (PyInt_Check(result) || PyBool_Check(result) || PyFloat_Check(result) ||
 PyStr_Check(result) || PyComplex_Check(result)) {
 return result;
 }
 return bp::return_internal_reference<>::postcall(args_, result);
 }
};

template <typename Variant>
struct VariantConverter {
 typedef Variant variant_type;
 typedef ReturnInternalVariant<variant_type> return_internal_reference;

 static void registration() {
 typedef details::VariantValueToObject<variant_type> variant_to_value;
 typedef typename details::VariantAlternatives<variant_type>::types types;

 bp::to_python_converter<variant_type, variant_to_value>();
 boost::mpl::for_each<types>(details::VariantConvertible<variant_type>());
 }
};

} // namespace eigenpy

#endif // ifndef __eigenpy_utils_variant_hpp__