Add function to safely cast to Python function

Author: Flamefire

src/classes.cpp

@@ -63,15 +63,14 @@ namespace scorepy
 PyTypeObject& getCInstrumenterType()
 {
     static PyMethodDef methods[] = {
-        { "_enable_instrumenter", reinterpret_cast<PyCFunction>(CInstrumenter_enable_instrumenter),
+        { "_enable_instrumenter", scorepy::castToPyFunc(CInstrumenter_enable_instrumenter),
           METH_NOARGS, "Enable the instrumenter" },
-        { "_disable_instrumenter",
-          reinterpret_cast<PyCFunction>(CInstrumenter_disable_instrumenter), METH_NOARGS,
-          "Disable the instrumenter" },
+        { "_disable_instrumenter", scorepy::castToPyFunc(CInstrumenter_disable_instrumenter),
+          METH_NOARGS, "Disable the instrumenter" },
         { nullptr } /* Sentinel */
     };
     static PyGetSetDef getseters[] = {
-        { "tracingOrProfiling", reinterpret_cast<getter>(CInstrumenter_get_tracingOrProfiling),
+        { "tracingOrProfiling", scorepy::castToPyFunc(CInstrumenter_get_tracingOrProfiling),
           nullptr, "Return whether the trace (True) or profile (False) instrumentation is used",
           nullptr },
         { nullptr } /* Sentinel */
@@ -83,7 +82,7 @@ PyTypeObject& getCInstrumenterType()
         sizeof(CInstrumenter),                  /* tp_basicsize */
     };
     type.tp_new = call_object_new;
-    type.tp_init = reinterpret_cast<initproc>(CInstrumenter_init);
+    type.tp_init = scorepy::castToPyFunc(CInstrumenter_init);
     type.tp_methods = methods;
     type.tp_getset = getseters;
     type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;

src/scorepy/pythonHelpers.hpp

@@ -3,6 +3,7 @@
 #include <Python.h>
 #include <frameobject.h>
 #include <string>
+#include <type_traits>
 
 namespace scorepy
 {
@@ -53,10 +54,61 @@ class PyRefObject
     }
 };
 
+namespace detail
+{
+    template <typename TFunc>
+    struct ReplaceArgsToPyObject;
+
+    template <typename TFunc>
+    using ReplaceArgsToPyObject_t = typename ReplaceArgsToPyObject<TFunc>::type;
+} // namespace detail
+
+/// Cast a function pointer to a python-bindings compatible function pointer
+/// Replaces all Foo* by PyObject* for all types Foo that are PyObject compatible
+template <typename TFunc>
+auto castToPyFunc(TFunc* func) -> detail::ReplaceArgsToPyObject_t<TFunc>*
+{
+    return reinterpret_cast<detail::ReplaceArgsToPyObject_t<TFunc>*>(func);
+}
+
 /// Return the module name the frame belongs to.
 /// The pointer is valid for the lifetime of the frame
 const char* get_module_name(const PyFrameObject& frame);
 /// Return the file name the frame belongs to
 std::string get_file_name(const PyFrameObject& frame);
 
+// Implementation details
+namespace detail
+{
+
+    template <typename>
+    struct make_void
+    {
+        typedef void type;
+    };
+    template <typename T>
+    using void_t = typename make_void<T>::type;
+
+    template <class T, class = void>
+    struct IsPyObject : std::false_type
+    {
+    };
+    template <class T>
+    struct IsPyObject<T*> : IsPyObject<T>
+    {
+    };
+
+    template <class T>
+    struct IsPyObject<T, void_t<decltype(std::declval<T>().toPyObject())>> : std::true_type
+    {
+    };
+
+    template <typename TResult, typename... TArgs>
+    struct ReplaceArgsToPyObject<TResult(TArgs...)>
+    {
+        template <typename T>
+        using replace = typename std::conditional<IsPyObject<T>::value, PyObject*, T>::type;
+        using type = TResult(replace<TArgs>...);
+    };
+} // namespace detail
 } // namespace scorepy