[ntuple] Rename RNTupleComposer data members and functions

...to reflect the separation between `RNTupleProcessor` and
  `RNTupleComposer`.

Author: enirolf

tree/ntuple/inc/ROOT/RNTupleComposer.hxx

@@ -181,7 +181,7 @@ TEST_F(RNTupleComposerTest, Base)
    } catch (const ROOT::RException &err) {
       EXPECT_THAT(err.what(),
                   testing::HasSubstr("cannot register field with name \"z\" because it is not present in the on-disk "
-                                     "information of the RNTuple(s) this processor is created from"));
+                                     "information of the RNTuple(s) this composition is created from"));
    }
 
    auto processor = RNTupleProcessor(*composer);

tree/ntuple/src/RNTupleComposer.cxx

@@ -99,12 +99,12 @@ TEST_F(RNTupleChainComposerTest, Basic)
 {
    auto composer = RNTupleComposer::CreateChain({{fNTupleName, fFileNames[0]}, {fNTupleName, fFileNames[1]}});
 
-   EXPECT_STREQ("ntuple", composer->GetProcessorName().c_str());
+   EXPECT_STREQ("ntuple", composer->GetCompositionName().c_str());
 
    {
       auto namedProc =
          RNTupleComposer::CreateChain({{fNTupleName, fFileNames[0]}, {fNTupleName, fFileNames[1]}}, "my_ntuple");
-      EXPECT_STREQ("my_ntuple", namedProc->GetProcessorName().c_str());
+      EXPECT_STREQ("my_ntuple", namedProc->GetCompositionName().c_str());
    }
 
    auto x = composer->RequestField<float>("x");
@@ -198,19 +198,19 @@ TEST_F(RNTupleChainComposerTest, LoadRandomEntry)
 
    RNTupleComposerEntryLoader::LoadEntry(*composer, 3);
    EXPECT_EQ(3.f, *x);
-   EXPECT_EQ(0, composer->GetCurrentProcessorNumber());
+   EXPECT_EQ(0, composer->GetCurrentChainIndex());
 
    RNTupleComposerEntryLoader::LoadEntry(*composer, 9);
    EXPECT_EQ(9.f, *x);
-   EXPECT_EQ(1, composer->GetCurrentProcessorNumber());
+   EXPECT_EQ(1, composer->GetCurrentChainIndex());
 
    RNTupleComposerEntryLoader::LoadEntry(*composer, 6);
    EXPECT_EQ(6.f, *x);
-   EXPECT_EQ(1, composer->GetCurrentProcessorNumber());
+   EXPECT_EQ(1, composer->GetCurrentChainIndex());
 
    RNTupleComposerEntryLoader::LoadEntry(*composer, 2);
    EXPECT_EQ(2.f, *x);
-   EXPECT_EQ(0, composer->GetCurrentProcessorNumber());
+   EXPECT_EQ(0, composer->GetCurrentChainIndex());
 
    EXPECT_EQ(ROOT::kInvalidNTupleIndex, RNTupleComposerEntryLoader::LoadEntry(*composer, 10));
 }

tree/ntuple/test/ntuple_composer.cxx

@@ -197,38 +197,39 @@ TEST_F(RNTupleJoinComposerTest, UnalignedMultipleJoinFields)
    try {
       RNTupleComposer::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]},
                                   {"i", "j", "k", "l", "m"});
-      FAIL() << "trying to create a join processor with more than four join fields should throw";
+      FAIL() << "trying to create an RNTupleJoinComposer with more than four join fields should throw";
    } catch (const ROOT::RException &err) {
       EXPECT_THAT(err.what(), testing::HasSubstr("a maximum of four join fields is allowed"));
    }
 
    try {
       RNTupleComposer::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[3], fFileNames[3]}, {"i", "i"});
-      FAIL() << "trying to create a join processor with duplicate join fields should throw";
+      FAIL() << "trying to create an RNTupleJoinComposer with duplicate join fields should throw";
    } catch (const ROOT::RException &err) {
       EXPECT_THAT(err.what(), testing::HasSubstr("join fields must be unique"));
    }
 
    try {
       auto composer =
          RNTupleComposer::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]}, {"l"});
-      // Without registering a field, the processor won't be initialized.
+      // Without registering a field, the compoer won't be initialized.
       composer->RequestField<float>("x");
-      FAIL() << "trying to use a join processor where not all join fields are present in the primary processor should "
-                "throw";
+      FAIL() << "trying to use an RNTupleJoinComposer where not all join fields are present in the primary composition "
+                "should throw";
    } catch (const ROOT::RException &err) {
-      EXPECT_THAT(err.what(), testing::HasSubstr("could not find join field \"l\" in primary processor \"ntuple1\""));
+      EXPECT_THAT(err.what(), testing::HasSubstr("could not find join field \"l\" in primary composition \"ntuple1\""));
    }
 
    try {
       auto composer = RNTupleComposer::CreateJoin({fNTupleNames[0], fFileNames[0]}, {fNTupleNames[1], fFileNames[1]},
                                                   {"i", "j", "k"});
-      // Without registering a field, the processor won't be initialized.
+      // Without registering a field, the composer won't be initialized.
       composer->RequestField<float>("x");
-      FAIL() << "trying to use a join processor where not all join fields are present in the auxiliary processor "
-                "should throw";
+      FAIL() << "trying to use an RNTupleJoinComposer where not all join fields are present in the auxiliary "
+                "composition should throw";
    } catch (const ROOT::RException &err) {
-      EXPECT_THAT(err.what(), testing::HasSubstr("could not find join field \"j\" in auxiliary processor \"ntuple2\""));
+      EXPECT_THAT(err.what(),
+                  testing::HasSubstr("could not find join field \"j\" in auxiliary composition \"ntuple2\""));
    }
 
    auto composer =

tree/ntuple/test/ntuple_composer_chain.cxx

@@ -68,7 +68,7 @@ void Read(const std::vector<RNTupleOpenSpec> &ntuples)
    // The chain-based composition can be created by passing a list of RNTupleOpenSpecs, describing the name and location
    // of each RNTuple in the chain.
    auto composer = RNTupleComposer::CreateChain(ntuples);
-   int prevProcessorNumber{-1};
+   int prevChainIdx{-1};
 
    // Access to the composition's fields is done by first requesting them through RNTupleComposer::RequestField(). The
    // returned value can be used to read the current entry's value for that particular field.
@@ -80,10 +80,10 @@ void Read(const std::vector<RNTupleOpenSpec> &ntuples)
    // The iterator value is the index of the current entry being processed.
    for (auto idx : processor) {
       // The RNTupleProcessor provides some additional bookkeeping information, such as the current processor number.
-      if (static_cast<int>(composer->GetCurrentProcessorNumber()) > prevProcessorNumber) {
-         prevProcessorNumber = composer->GetCurrentProcessorNumber();
-         std::cout << "Processing `ntuple" << prevProcessorNumber + 1 << "` (" << idx + 1
-                   << " total entries processed so far)" << std::endl;
+      if (static_cast<int>(composer->GetCurrentChainIndex()) > prevChainIdx) {
+         prevChainIdx = composer->GetCurrentChainIndex();
+         std::cout << "Processing `ntuple" << prevChainIdx + 1 << "` (" << idx + 1 << " total entries processed so far)"
+                   << std::endl;
       }
 
       // We use the value returned from requesting the field to read its data for the current entry.