[PyROOT] Get names and types of all overloads' signature

Author: vepadulano

bindings/pyroot/cppyy/CPyCppyy/src/CPPMethod.cxx

@@ -801,8 +801,41 @@ PyObject* CPyCppyy::CPPMethod::GetSignature(bool fa)
     return CPyCppyy_PyText_FromString(GetSignatureString(fa).c_str());
 }
 
+PyObject *CPyCppyy::CPPMethod::GetSignatureNames()
+{
+   // Build a tuple of the argument names for this signature.
+   int argcount = GetMaxArgs();
+
+   PyObject *signature_names = PyTuple_New(argcount);
+   for (int iarg = 0; iarg < argcount; ++iarg) {
+      const std::string &argname_cpp = Cppyy::GetMethodArgName(fMethod, iarg);
+
+      PyObject *argname_py = CPyCppyy_PyText_FromString(argname_cpp.c_str());
+      PyTuple_SET_ITEM(signature_names, iarg, argname_py);
+   }
+
+   return signature_names;
+}
+
+PyObject *CPyCppyy::CPPMethod::GetSignatureTypes()
+{
+   // Build a tuple of the argument types for this signature.
+   int argcount = GetMaxArgs();
+
+   PyObject *signature_types = PyTuple_New(argcount);
+   for (int iarg = 0; iarg < argcount; ++iarg) {
+      const std::string &argtype_cpp = Cppyy::GetMethodArgType(fMethod, iarg);
+
+      PyObject *argtype_py = CPyCppyy_PyText_FromString(argtype_cpp.c_str());
+      PyTuple_SET_ITEM(signature_types, iarg, argtype_py);
+   }
+
+   return signature_types;
+}
+
 //----------------------------------------------------------------------------
 std::string CPyCppyy::CPPMethod::GetReturnTypeName()
 {
     return Cppyy::GetMethodResultType(fMethod);
 }
+

bindings/pyroot/cppyy/CPyCppyy/src/CPPMethod.h

@@ -24,6 +24,8 @@ class CPPMethod : public PyCallable {
 
 public:
     virtual PyObject* GetSignature(bool show_formalargs = true);
+    PyObject* GetSignatureNames() override;
+    PyObject* GetSignatureTypes() override;
     virtual PyObject* GetPrototype(bool show_formalargs = true);
     virtual int       GetPriority();
     virtual bool IsGreedy();
@@ -88,3 +90,4 @@ class CPPMethod : public PyCallable {
 } // namespace CPyCppyy
 
 #endif // !CPYCPPYY_CPPMETHOD_H
+

bindings/pyroot/cppyy/CPyCppyy/src/CPPOverload.cxx

@@ -58,6 +58,16 @@ class TPythonCallback : public PyCallable {
     virtual PyObject* GetSignature(bool /*show_formalargs*/ = true) {
         return CPyCppyy_PyText_FromString("*args, **kwargs");
     }
+
+
+    PyObject* GetSignatureNames() override {
+        return PyTuple_New(0);
+    }
+
+    PyObject* GetSignatureTypes() override {
+        return PyTuple_New(0);
+    }
+
     virtual PyObject* GetPrototype(bool /*show_formalargs*/ = true) {
         return CPyCppyy_PyText_FromString("<callback>");
     }
@@ -241,6 +251,42 @@ static PyObject* mp_doc(CPPOverload* pymeth, void*)
     return doc;
 }
 
+static PyObject* mp_func_overloads_types(CPPOverload* pymeth, void*)
+{
+
+    CPPOverload::Methods_t& methods = pymeth->fMethodInfo->fMethods;
+
+    CPPOverload::Methods_t::size_type nMethods = methods.size();
+    if (nMethods == 0) // from template proxy with no instantiations
+        return nullptr;
+
+    PyObject* overloads_types_dict = PyDict_New();
+    for (CPPOverload::Methods_t::size_type i = 0; i < nMethods; ++i) {
+        PyDict_SetItem(overloads_types_dict, methods[i]->GetSignature(), methods[i]->GetSignatureTypes());
+    }
+
+    return overloads_types_dict;
+
+}
+
+static PyObject* mp_func_overloads_names(CPPOverload* pymeth, void*)
+{
+
+    CPPOverload::Methods_t& methods = pymeth->fMethodInfo->fMethods;
+
+    CPPOverload::Methods_t::size_type nMethods = methods.size();
+    if (nMethods == 0) // from template proxy with no instantiations
+        return nullptr;
+
+    PyObject* overloads_names_dict = PyDict_New();
+    for (CPPOverload::Methods_t::size_type i = 0; i < nMethods; ++i) {
+        PyDict_SetItem(overloads_names_dict, methods[i]->GetSignature(), methods[i]->GetSignatureNames());
+    }
+
+    return overloads_names_dict;
+
+}
+
 //----------------------------------------------------------------------------
 static PyObject* mp_meth_func(CPPOverload* pymeth, void*)
 {
@@ -514,6 +560,8 @@ static PyGetSetDef mp_getset[] = {
     {(char*)"func_globals",  (getter)mp_func_globals,  nullptr, nullptr, nullptr},
     {(char*)"func_doc",      (getter)mp_doc,           nullptr, nullptr, nullptr},
     {(char*)"func_name",     (getter)mp_name,          nullptr, nullptr, nullptr},
+    {(char*)"func_overloads_types",    (getter)mp_func_overloads_types,    nullptr, nullptr, nullptr},
+    {(char*)"func_overloads_names",    (getter)mp_func_overloads_names,    nullptr, nullptr, nullptr},
 
     {(char*)"__creates__",         (getter)mp_getcreates, (setter)mp_setcreates,
       (char*)"For ownership rules of result: if true, objects are python-owned", nullptr},
@@ -971,3 +1019,4 @@ CPyCppyy::CPPOverload::MethodInfo_t::~MethodInfo_t()
 }
 
 // TODO: something like PyMethod_Fini to clear up the free_list
+

bindings/pyroot/cppyy/CPyCppyy/src/PyCallable.h

@@ -15,6 +15,8 @@ class PyCallable {
 
 public:
     virtual PyObject* GetSignature(bool show_formalargs = true) = 0;
+    virtual PyObject* GetSignatureNames() = 0;
+    virtual PyObject* GetSignatureTypes() = 0;
     virtual PyObject* GetPrototype(bool show_formalargs = true) = 0;
     virtual PyObject* GetDocString() { return GetPrototype(); }
 
@@ -38,3 +40,4 @@ class PyCallable {
 } // namespace CPyCppyy
 
 #endif // !CPYCPPYY_PYCALLABLE_H
+