.. _program_listing_file__tmp_ws_src_eigenpy_include_eigenpy_variant.hpp:

Program Listing for File variant.hpp
====================================

|exhale_lsh| :ref:`Return to documentation for file <file__tmp_ws_src_eigenpy_include_eigenpy_variant.hpp>` (``/tmp/ws/src/eigenpy/include/eigenpy/variant.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   //
   // 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__