utils: add type_info helpers

Author: jcarpent

CMakeLists.txt

@@ -275,6 +275,7 @@ set(${PROJECT_NAME}_HEADERS
     include/eigenpy/variant.hpp
     include/eigenpy/std-unique-ptr.hpp
     include/eigenpy/swig.hpp
+    include/eigenpy/type_info.hpp
     include/eigenpy/version.hpp)
 
 list(
@@ -349,6 +350,7 @@ set(${PROJECT_NAME}_SOURCES
     src/scipy-type.cpp
     src/std-vector.cpp
     src/optional.cpp
+    src/type_info.cpp
     src/version.cpp)
 
 add_library(${PROJECT_NAME} SHARED ${${PROJECT_NAME}_SOURCES}

include/eigenpy/type_info.hpp

@@ -0,0 +1,77 @@
+///
+/// Copyright (c) 2024 INRIA
+///
+
+#ifndef __eigenpy_type_info_hpp__
+#define __eigenpy_type_info_hpp__
+
+#include "eigenpy/fwd.hpp"
+
+#include <boost/type_index.hpp>
+#include <typeinfo>
+#include <typeindex>
+
+namespace eigenpy {
+
+template <typename T>
+boost::typeindex::type_index type_info(const T& value) {
+  return boost::typeindex::type_id_runtime(value);
+}
+
+template <typename T>
+void expose_boost_type_info() {
+  boost::python::def(
+      "type_info",
+      +[](const T& value) -> boost::typeindex::type_index {
+        return boost::typeindex::type_id_runtime(value);
+      },
+      bp::arg("value"),
+      "Returns information of the type of value as a "
+      "boost::typeindex::type_index (can work without RTTI).");
+  boost::python::def(
+      "boost_type_info",
+      +[](const T& value) -> boost::typeindex::type_index {
+        return boost::typeindex::type_id_runtime(value);
+      },
+      bp::arg("value"),
+      "Returns information of the type of value as a "
+      "boost::typeindex::type_index (can work without RTTI).");
+}
+
+template <typename T>
+void expose_std_type_info() {
+  boost::python::def(
+      "std_type_info",
+      +[](const T& value) -> std::type_index { return typeid(value); },
+      bp::arg("value"),
+      "Returns information of the type of value as a std::type_index.");
+}
+
+///
+/// \brief Add the Python method type_info to query information of a type.
+///
+template <class C>
+struct TypeInfoVisitor : public bp::def_visitor<TypeInfoVisitor<C> > {
+  template <class PyClass>
+  void visit(PyClass& cl) const {
+    cl.def("type_info", &boost_type_info, bp::arg("self"),
+           "Queries information of the type of *this as a "
+           "boost::typeindex::type_index (can work without RTTI).");
+    cl.def("boost_type_info", &boost_type_info, bp::arg("self"),
+           "Queries information of the type of *this as a "
+           "boost::typeindex::type_index (can work without RTTI).");
+    cl.def("std_type_info", &std_type_info, bp::arg("self"),
+           "Queries information of the type of *this as a std::type_index.");
+  }
+
+ private:
+  static boost::typeindex::type_index boost_type_info(const C& self) {
+    return boost::typeindex::type_id<C>();
+  }
+
+  static std::type_index std_type_info(const C& self) { return typeid(C); }
+};
+
+}  // namespace eigenpy
+
+#endif  // __eigenpy_type_info_hpp__

src/eigenpy.cpp

@@ -36,6 +36,7 @@ void exposeMatrixComplexDouble();
 void exposeMatrixComplexLongDouble();
 
 void exposeNoneType();
+void exposeTypeInfo();
 
 /* Enable Eigen-Numpy serialization for a set of standard MatrixBase instances.
  */
@@ -84,6 +85,7 @@ void enableEigenPy() {
   exposeMatrixComplexLongDouble();
 
   exposeNoneType();
+  exposeTypeInfo();
 }
 
 bool withTensorSupport() {

src/type_info.cpp

@@ -0,0 +1,68 @@
+///
+/// Copyright 2024 INRIA
+///
+
+#include <typeinfo>
+#include <typeindex>
+
+#include <boost/python.hpp>
+#include <boost/type_index.hpp>
+
+namespace bp = boost::python;
+
+void exposeStdTypeIndex() {
+  typedef std::type_index Self;
+  bp::class_<Self>(
+      "std_type_index",
+      "The class type_index holds implementation-specific information about a "
+      "type, including the name of the type and means to compare two types for "
+      "equality or collating order.",
+      bp::no_init)
+      .def(bp::self == bp::self)
+      .def(bp::self >= bp::self)
+      .def(bp::self > bp::self)
+      .def(bp::self < bp::self)
+      .def(bp::self <= bp::self)
+      .def("hash_code", &Self::hash_code, bp::arg("self"),
+           "Returns an unspecified value (here denoted by hash code) such that "
+           "for all std::type_info objects referring to the same type, their "
+           "hash code is the same.")
+      .def("name", &Self::name, bp::arg("self"),
+           "Returns an implementation defined null-terminated character string "
+           "containing the name of the type. No guarantees are given; in "
+           "particular, the returned string can be identical for several types "
+           "and change between invocations of the same program.");
+}
+
+void exposeBoostTypeIndex() {
+  typedef boost::typeindex::type_index Self;
+  bp::class_<Self>(
+      "boost_type_index",
+      "The class type_index holds implementation-specific information about a "
+      "type, including the name of the type and means to compare two types for "
+      "equality or collating order.",
+      bp::no_init)
+      .def(bp::self == bp::self)
+      .def(bp::self >= bp::self)
+      .def(bp::self > bp::self)
+      .def(bp::self < bp::self)
+      .def(bp::self <= bp::self)
+      .def("hash_code", &Self::hash_code, bp::arg("self"),
+           "Returns an unspecified value (here denoted by hash code) such that "
+           "for all std::type_info objects referring to the same type, their "
+           "hash code is the same.")
+      .def("name", &Self::name, bp::arg("self"),
+           "Returns an implementation defined null-terminated character string "
+           "containing the name of the type. No guarantees are given; in "
+           "particular, the returned string can be identical for several types "
+           "and change between invocations of the same program.")
+      .def("pretty_name", &Self::pretty_name, bp::arg("self"),
+           "Human readible name.");
+}
+
+namespace eigenpy {
+void exposeTypeInfo() {
+  exposeStdTypeIndex();
+  exposeBoostTypeIndex();
+}
+}  // namespace eigenpy