[ntuple] fix automatic schema evolution of pair/tuple

For std::pair and std::tuple, check that the number of subfields in
memory and on disk is identical. For 2 subfields, std::pair and
std::tuple are interchangible. The pair/tuple elements don't need to be
an exact match but are themselves subject to automatic schema evolution.

Author: jblomer

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

@@ -136,6 +136,8 @@ protected:
    RPairField(std::string_view fieldName, std::array<std::unique_ptr<RFieldBase>, 2> itemFields,
               const std::array<std::size_t, 2> &offsets);
 
+   void ReconcileOnDiskField(const RNTupleDescriptor &desc) final;
+
 public:
    RPairField(std::string_view fieldName, std::array<std::unique_ptr<RFieldBase>, 2> itemFields);
    RPairField(RPairField &&other) = default;
@@ -186,6 +188,8 @@ protected:
    RTupleField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields,
                const std::vector<std::size_t> &offsets);
 
+   void ReconcileOnDiskField(const RNTupleDescriptor &desc) final;
+
 public:
    RTupleField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields);
    RTupleField(RTupleField &&other) = default;

tree/ntuple/src/RFieldMeta.cxx

@@ -624,6 +624,21 @@ ROOT::RPairField::RPairField(std::string_view fieldName, std::array<std::unique_
    fOffsets.push_back(secondElem->GetThisOffset());
 }
 
+void ROOT::RPairField::ReconcileOnDiskField(const RNTupleDescriptor &desc)
+{
+   static const std::vector<std::string> prefixes = {"std::pair<", "std::tuple<"};
+
+   const auto &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());
+   EnsureMatchingOnDiskField(fieldDesc, kDiffTypeName);
+   EnsureMatchingTypePrefix(fieldDesc, prefixes);
+
+   const auto nOnDiskSubfields = fieldDesc.GetLinkIds().size();
+   if (nOnDiskSubfields != 2) {
+      throw ROOT::RException(
+         R__FAIL("invalid number of on-disk subfields for std::pair " + std::to_string(nOnDiskSubfields)));
+   }
+}
+
 //------------------------------------------------------------------------------
 
 ROOT::RProxiedCollectionField::RCollectionIterableOnce::RIteratorFuncs
@@ -1151,6 +1166,22 @@ ROOT::RTupleField::RTupleField(std::string_view fieldName, std::vector<std::uniq
    }
 }
 
+void ROOT::RTupleField::ReconcileOnDiskField(const RNTupleDescriptor &desc)
+{
+   static const std::vector<std::string> prefixes = {"std::pair<", "std::tuple<"};
+
+   const auto &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());
+   EnsureMatchingOnDiskField(fieldDesc, kDiffTypeName);
+   EnsureMatchingTypePrefix(fieldDesc, prefixes);
+
+   const auto nOnDiskSubfields = fieldDesc.GetLinkIds().size();
+   const auto nSubfields = fSubfields.size();
+   if (nOnDiskSubfields != nSubfields) {
+      throw ROOT::RException(R__FAIL("invalid number of on-disk subfields for std::tuple " +
+                                     std::to_string(nOnDiskSubfields) + " vs. " + std::to_string(nSubfields)));
+   }
+}
+
 //------------------------------------------------------------------------------
 
 namespace {

tree/ntuple/test/ntuple_evolution_type.cxx

@@ -4,6 +4,7 @@
 #include <new>
 #include <string>
 #include <string_view>
+#include <tuple>
 #include <utility>
 
 class RNewStringField final : public ROOT::RFieldBase {
@@ -122,3 +123,49 @@ TEST(RNTupleEvolution, CheckRepetitionCount)
       EXPECT_THAT(err.what(), testing::HasSubstr("repetition count 3 vs. 2"));
    }
 }
+
+TEST(RNTupleEvolution, CheckPairTuple)
+{
+   FileRaii fileGuard("test_ntuple_evolution_check_pair_tuple.root");
+   {
+      auto model = ROOT::RNTupleModel::Create();
+      auto p = model->MakeField<std::pair<char, float>>("p");
+      auto t2 = model->MakeField<std::tuple<char, float>>("t2");
+      model->MakeField<std::tuple<char, float, float>>("t3");
+      auto writer = ROOT::RNTupleWriter::Recreate(std::move(model), "ntpl", fileGuard.GetPath());
+
+      *p = {1, 2.0};
+      *t2 = {3, 4.0};
+      writer->Fill();
+   }
+
+   auto reader = RNTupleReader::Open("ntpl", fileGuard.GetPath());
+
+   try {
+      reader->GetView<std::tuple<char>>("p");
+      FAIL() << "non-matching number of subfields for pair/tuple should throw";
+   } catch (const ROOT::RException &err) {
+      EXPECT_THAT(err.what(), testing::HasSubstr("invalid number of on-disk subfields"));
+   }
+
+   try {
+      reader->GetView<std::tuple<char, float, float>>("p");
+      FAIL() << "non-matching number of subfields for pair/tuple should throw";
+   } catch (const ROOT::RException &err) {
+      EXPECT_THAT(err.what(), testing::HasSubstr("invalid number of on-disk subfields"));
+   }
+
+   try {
+      reader->GetView<std::pair<char, float>>("t3");
+      FAIL() << "non-matching number of subfields for pair/tuple should throw";
+   } catch (const ROOT::RException &err) {
+      EXPECT_THAT(err.what(), testing::HasSubstr("invalid number of on-disk subfields"));
+   }
+
+   auto t2 = reader->GetView<std::pair<char, double>>("t2");
+   auto p = reader->GetView<std::tuple<int, double>>("p");
+   EXPECT_EQ(3, t2(0).first);
+   EXPECT_DOUBLE_EQ(4.0, t2(0).second);
+   EXPECT_EQ(1, std::get<0>(p(0)));
+   EXPECT_DOUBLE_EQ(2.0, std::get<1>(p(0)));
+}