Try alternative names in REntry._GetPtr

Fixes the case of instantiating a C++ function template via
a Python TemplateProxy when a template argument passed by string (and
thus lazily evaluated) is of a type that has alternative names available
in the type system. Previously, only the user-provided type name was
tried to instantiate the function template `REntry::GetPtr` from the
RNTuple pythonization. Now, the pythonization first tries to instantiate
the function template via the user-provided string and, failing that, it
falls back to retrying the instantiation using all the available
alternative names for the name of the field type.

A new API in TClassTable is made available for this purpose. The list of
available alternative names for an input type name can now be queried
via `TClassTable::GetClassAlternativeNames`.

One advantage of this approach is that it does not require any change in
the RNTuple library and in cppyy. Also, it does not involve any change
in behaviour in core, the new API is completely detached from any
pre-existing code paths. One disadvantage is that in order to actually
trigger the right function template instantiation there needs to be some
manual work, currently done in the Pythonization of `REntry::GetPtr`. In
general, if a user were to write a C++ template function that needs to
take in a template argument type of the same kind of
AtlasLikeDataVector, they would need to try the first template
instantiation, see it failing, then retry again after querying the list
of alternative class names. This workflow is exemplified with a test.

Making this approach fully generic would require changes in cppyy which
on the surface look quite invasive. For example if a function has
multiple template arguments and all of them have multiple alternative
class names, one would probably need to trigger all the combinations of
template instantiations to look for the right one.

cherry-picked from f1fdd79 modulo the
changes made in roottest, which is not part of the root repository in
the v6-36-00-patches branch.

Author: vepadulano

bindings/pyroot/pythonizations/python/ROOT/_pythonization/_rntuple.py

@@ -15,13 +15,46 @@
 def _REntry_GetPtr(self, key):
     raise RuntimeError("GetPtr is not supported in Python, use indexing")
 
+def _try_getptr(entry, fieldType, key):
+    rentry_getptr_typeerrors = []
+    try:
+        return entry._GetPtr[fieldType](key)
+    except TypeError as e:
+        # The input field type name might not be found when trying to instantiate
+        # the template via the Python bindings. At the moment, there is one
+        # notable case when this happens. If the type name corresponds to a class
+        # that has alternative names registered via its dictionary, the name
+        # passed by the user may not be the fully qualified name seen by the
+        # compiler. We tap into the knowledge of TClassTable to look for all the
+        # alternative names, and try if there is a correspondence with one of those.
+        # Note: clearly a prerequisite for the following section to work is that
+        # the dictionary of the class was loaded and its alternative names were
+        # registered. This currently happens at loading time of the RNTupleModel
+        # which loads the classes found in the schema and also during the first
+        # attempt at calling _GetPtr with the user-provided class name (in
+        # particular when it tries to instantiate the function template)
+        rentry_getptr_typeerrors.append(e)
+        import ROOT
+        alt_field_type_names = ROOT.TClassTable.GetClassAlternativeNames(fieldType)
+        for alt_field_type_name in alt_field_type_names:
+            try:
+                # Need to convert std::string to Python string
+                return entry._GetPtr[str(alt_field_type_name)](key)
+            except TypeError as alt_e:
+                rentry_getptr_typeerrors.append(alt_e)
+
+    err_msg = f"Failed to retrieve entry value for field type name '{fieldType}'. Full stack trace follows:\n"
+    for ex in rentry_getptr_typeerrors:
+        err_msg += str(ex) + "\n"
+
+    raise TypeError(err_msg)
 
 def _REntry_CallGetPtr(self, key):
     # key can be either a RFieldToken already or a string. In the latter case, get a token to use it twice.
     if not hasattr(type(key), "__cpp_name__") or type(key).__cpp_name__ != "ROOT::RFieldToken":
         key = self.GetToken(key)
     fieldType = self.GetTypeName(key)
-    return self._GetPtr[fieldType](key)
+    return _try_getptr(self, fieldType, key)
 
 
 def _REntry_getitem(self, key):

core/cont/inc/TClassTable.h

@@ -25,6 +25,7 @@
 #include "TObject.h"
 #include <string>
 #include <atomic>
+#include <vector>
 
 class TProtoClass;
 
@@ -80,6 +81,7 @@ friend  class TROOT;
                                Int_t pragmabits);
    static void             Add(TProtoClass *protoClass);
    static ROOT::TClassAlt *AddAlternate(const char *normname, const char *alternate);
+   static std::vector<std::string> GetClassAlternativeNames(const char *cname);
    static char            *At(UInt_t index);
    int                     Classes();
    static Bool_t           Check(const char *cname, std::string &normname);

core/cont/src/TClassTable.cxx

@@ -41,6 +41,7 @@ All functions in TClassTable are thread-safe.
 #include <cstdlib>
 #include <string>
 #include <mutex>
+#include <unordered_map>
 
 using namespace ROOT;
 
@@ -258,6 +259,12 @@ namespace ROOT {
    }
 }
 
+std::unordered_map<ROOT::TClassRec *, std::vector<ROOT::TClassAlt *>> &GetClassRecToAltMap()
+{
+   static std::unordered_map<ROOT::TClassRec *, std::vector<ROOT::TClassAlt *>> classRecToAltMap;
+   return classRecToAltMap;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 /// TClassTable is a singleton (i.e. only one can exist per application).
 
@@ -270,7 +277,7 @@ TClassTable::TClassTable()
    fgAlternate = new TClassAlt* [fgSize];
    fgIdMap = new IdMap_t;
    memset(fgTable, 0, fgSize * sizeof(TClassRec*));
-   memset(fgAlternate, 0, fgSize * sizeof(TClassAlt*));
+   memset(fgAlternate, 0, fgSize * sizeof(TClassAlt *));
    gClassTable = this;
 
    for (auto &&r : GetDelayedAddClass()) {
@@ -528,6 +535,17 @@ ROOT::TClassAlt* TClassTable::AddAlternate(const char *normName, const char *alt
    }
 
    fgAlternate[slot] = new TClassAlt(alternate,normName,fgAlternate[slot]);
+
+   UInt_t slotNorm = ROOT::ClassTableHash(normName, fgSize);
+   if (fgTable[slotNorm]) {
+      auto &classToAlt = GetClassRecToAltMap();
+      // Let others connect a class record to its class alternative names
+      if (auto it = classToAlt.find(fgTable[slotNorm]); it == classToAlt.end())
+         classToAlt[fgTable[slotNorm]] = std::vector<ROOT::TClassAlt *>{fgAlternate[slot]};
+      else
+         classToAlt[fgTable[slotNorm]].push_back(fgAlternate[slot]);
+   }
+
    return fgAlternate[slot];
 }
 
@@ -1030,3 +1048,24 @@ TNamed *ROOT::RegisterClassTemplate(const char *name, const char *file,
    }
    return reg;
 }
+
+std::vector<std::string> TClassTable::GetClassAlternativeNames(const char *cname)
+{
+   std::lock_guard<std::mutex> lock(GetClassTableMutex());
+
+   UInt_t slot = ROOT::ClassTableHash(cname, fgSize);
+   if (!fgTable[slot])
+      return {};
+   const auto &classRecToAltMap = GetClassRecToAltMap();
+   if (auto it = classRecToAltMap.find(fgTable[slot]); it == classRecToAltMap.end())
+      return {};
+
+   const auto &classAlts = classRecToAltMap.at(fgTable[slot]);
+   std::vector<std::string> ret;
+   ret.reserve(classAlts.size());
+   for (const auto *classAlt : classAlts) {
+      ret.push_back(classAlt->fName);
+   }
+
+   return ret;
+}