[ntuple] fix collection proxy with [U]Long64_t template arg

Author: jblomer

tree/ntuple/inc/ROOT/RField/RFieldProxiedCollection.hxx

@@ -255,7 +255,7 @@ template <typename T>
 class RField<T, typename std::enable_if<IsCollectionProxy<T>::value>::type> final : public RProxiedCollectionField {
 public:
    static std::string TypeName() { return ROOT::Internal::GetRenormalizedTypeName(typeid(T)); }
-   RField(std::string_view name) : RProxiedCollectionField(name, TypeName())
+   RField(std::string_view name) : RProxiedCollectionField(name, Internal::GetDemangledTypeName(typeid(T)))
    {
       static_assert(std::is_class<T>::value, "collection proxy unsupported for fundamental types");
    }

tree/ntuple/src/RFieldMeta.cxx

@@ -748,7 +748,7 @@ ROOT::RProxiedCollectionField::RProxiedCollectionField(std::string_view fieldNam
      fNWritten(0)
 {
    if (!classp->GetCollectionProxy())
-      throw RException(R__FAIL(std::string(GetTypeName()) + " has no associated collection proxy"));
+      throw RException(R__FAIL(std::string(classp->GetName()) + " has no associated collection proxy"));
    if (classp->Property() & kIsDefinedInStd) {
       static const std::vector<std::string> supportedStdTypes = {
          "std::set<", "std::unordered_set<", "std::multiset<", "std::unordered_multiset<",
@@ -764,6 +764,10 @@ ROOT::RProxiedCollectionField::RProxiedCollectionField(std::string_view fieldNam
          throw RException(R__FAIL(std::string(GetTypeName()) + " is not supported"));
    }
 
+   std::string renormalizedAlias;
+   if (Internal::NeedsMetaNameAsAlias(classp->GetName(), renormalizedAlias))
+      fTypeAlias = renormalizedAlias;
+
    fProxy.reset(classp->GetCollectionProxy()->Generate());
    fProperties = fProxy->GetProperties();
    fCollectionType = fProxy->GetCollectionType();
@@ -801,7 +805,7 @@ ROOT::RProxiedCollectionField::RProxiedCollectionField(std::string_view fieldNam
       case EDataType::kFloat_t: itemField = std::make_unique<RField<Float_t>>("_0"); break;
       case EDataType::kDouble_t: itemField = std::make_unique<RField<Double_t>>("_0"); break;
       case EDataType::kBool_t: itemField = std::make_unique<RField<Bool_t>>("_0"); break;
-      default: throw RException(R__FAIL("unsupported value type"));
+      default: throw RException(R__FAIL("unsupported value type: " + std::to_string(fProxy->GetType())));
       }
    }
 

tree/ntuple/test/CustomStructLinkDef.h

@@ -67,6 +67,7 @@
 #pragma link C++ class StructUsingCollectionProxy<CustomStruct> + ;
 #pragma link C++ class StructUsingCollectionProxy<StructUsingCollectionProxy<float>> + ;
 #pragma link C++ class StructUsingCollectionProxy<int> + ;
+#pragma link C++ class StructUsingCollectionProxy<Long64_t>+;
 
 #pragma link C++ class TrivialTraitsBase + ;
 #pragma link C++ class TrivialTraits + ;

tree/ntuple/test/SimpleCollectionProxy.hxx

@@ -72,6 +72,8 @@ public:
          return EDataType::kInt_t;
       if constexpr (std::is_same<typename CollectionT::ValueType, float>::value)
          return EDataType::kFloat_t;
+      if constexpr (std::is_same<typename CollectionT::ValueType, Long64_t>::value)
+         return EDataType::kLong64_t;
       return EDataType::kOther_t;
    }
 
@@ -122,8 +124,9 @@ template <>
 struct IsCollectionProxy<StructUsingCollectionProxy<float>> : std::true_type {
 };
 template <>
-struct IsCollectionProxy<StructUsingCollectionProxy<CustomStruct>> : std::true_type {
-};
+struct IsCollectionProxy<StructUsingCollectionProxy<Long64_t>> : std::true_type {};
+template <>
+struct IsCollectionProxy<StructUsingCollectionProxy<CustomStruct>> : std::true_type {};
 
 template <>
 struct IsCollectionProxy<StructUsingCollectionProxy<StructUsingCollectionProxy<float>>> : std::true_type {

tree/ntuple/test/rfield_class.cxx

@@ -1,4 +1,5 @@
 #include "ntuple_test.hxx"
+#include "SimpleCollectionProxy.hxx"
 
 #include <TMath.h>
 #include <TObject.h>
@@ -391,6 +392,14 @@ TEST(RNTuple, TClassMetaName)
    auto f4 = RFieldBase::Create("f", "EdmContainer").Unwrap();
    EXPECT_STREQ("EdmWrapper<Long64_t>",
                 static_cast<const ROOT::RClassField *>(f4->GetConstSubfields()[0])->GetClass()->GetName());
+
+   SimpleCollectionProxy<StructUsingCollectionProxy<Long64_t>> proxy;
+   auto cl = TClass::GetClass("StructUsingCollectionProxy<Long64_t>");
+   cl->CopyCollectionProxy(proxy);
+
+   auto f5 = std::make_unique<ROOT::RField<StructUsingCollectionProxy<Long64_t>>>("f");
+   EXPECT_TRUE(dynamic_cast<ROOT::RProxiedCollectionField *>(f5.get()));
+   EXPECT_EQ("StructUsingCollectionProxy<Long64_t>", f5->GetTypeAlias());
 }
 
 TEST(RNTuple, StreamerInfoRecords)