[ntuple] rename RNTupleAttributeEntry::fEntry to fMetaEntry

Author: silverweed

tree/ntuple/inc/ROOT/RNTupleAttributeEntry.hxx

@@ -75,29 +75,41 @@ class RNTupleAttributeEntry final {
    friend class ROOT::Experimental::RNTupleAttributeSetWriter;
    friend class ROOT::Experimental::RNTupleAttributeSetReader;
 
-   std::unique_ptr<REntry> fEntry;
+   /// Entry containing the Attribute-specific fields (such as the entry range)
+   std::unique_ptr<REntry> fMetaEntry;
+   /* Entry containing to user-defined fields. It is "scoped" because the Attribute Model is organized like this:
+    *  
+    *                      FieldZero
+    *                          |
+    *                _________/ \_________
+    *               /        |            \
+    *     __entryStart  __entryLen    RecordField
+    *                                    / | \
+    *                            (user defined fields)
+    *
+    *  and the ScopedEntry is scoped under RecordField, as if it were its top-level field.
+    */
    std::unique_ptr<REntry> fScopedEntry;
    RNTupleAttributeRange fRange;
 
    static std::unique_ptr<REntry> CreateScopedEntry(ROOT::RNTupleModel &model);
    static std::pair<std::unique_ptr<REntry>, std::unique_ptr<REntry>> CreateInternalEntries(ROOT::RNTupleModel &model);
 
    /// Creates a pending AttributeEntry whose length is not determined yet.
-   /// `entry` is the "real" entry containing all the attribute data including the range, `scopedEntry` only contains
-   /// the values of the user-defined values.
-   RNTupleAttributeEntry(std::unique_ptr<REntry> entry, std::unique_ptr<REntry> scopedEntry, ROOT::NTupleSize_t start)
-      : fEntry(std::move(entry)),
+   /// `metaEntry` is the entry containing the range data, `scopedEntry` contains the user-defined values.
+   RNTupleAttributeEntry(std::unique_ptr<REntry> metaEntry, std::unique_ptr<REntry> scopedEntry,
+                         ROOT::NTupleSize_t start)
+      : fMetaEntry(std::move(metaEntry)),
         fScopedEntry(std::move(scopedEntry)),
         fRange(RNTupleAttributeRange::FromStartLength(start, 0))
    {
    }
 
    /// Creates an AttributeEntry with the given range.
-   /// `entry` is the "real" entry containing all the attribute data including the range, `scopedEntry` only contains
-   /// the values of the user-defined values.
+   /// `metaEntry` is the entry containing the range data, `scopedEntry` contains the user-defined values.
    RNTupleAttributeEntry(std::unique_ptr<REntry> entry, std::unique_ptr<REntry> scopedEntry,
                          RNTupleAttributeRange range)
-      : fEntry(std::move(entry)), fScopedEntry(std::move(scopedEntry)), fRange(range)
+      : fMetaEntry(std::move(entry)), fScopedEntry(std::move(scopedEntry)), fRange(range)
    {
    }
 

tree/ntuple/src/RNTupleAttributeEntry.cxx

@@ -18,7 +18,7 @@
 
 std::size_t ROOT::Experimental::RNTupleAttributeEntry::Append()
 {
-   auto bytesWritten = fEntry->Append();
+   auto bytesWritten = fMetaEntry->Append();
    bytesWritten += fScopedEntry->Append();
    return bytesWritten;
 }
@@ -47,18 +47,18 @@ std::unique_ptr<ROOT::REntry> ROOT::Experimental::RNTupleAttributeEntry::CreateS
 std::pair<std::unique_ptr<ROOT::REntry>, std::unique_ptr<ROOT::REntry>>
 ROOT::Experimental::RNTupleAttributeEntry::CreateInternalEntries(ROOT::RNTupleModel &model)
 {
-   auto entry = std::unique_ptr<ROOT::REntry>(new ROOT::REntry(model.GetModelId(), model.GetSchemaId()));
+   auto metaEntry = std::unique_ptr<ROOT::REntry>(new ROOT::REntry(model.GetModelId(), model.GetSchemaId()));
 
    auto &zeroField = ROOT::Internal::GetFieldZeroOfModel(const_cast<ROOT::RNTupleModel &>(model));
    auto subfields = zeroField.GetMutableSubfields();
    RFieldBase *rangeStartField = subfields[0]; // XXX: hardcoded
    RFieldBase *rangeLenField = subfields[1];   // XXX: hardcoded
 
-   // Add only the range start/len to `entry`
-   entry->AddValue(rangeStartField->CreateValue());
-   entry->AddValue(rangeLenField->CreateValue());
+   // Add only the range start/len to `metaEntry`
+   metaEntry->AddValue(rangeStartField->CreateValue());
+   metaEntry->AddValue(rangeLenField->CreateValue());
 
    auto scopedEntry = CreateScopedEntry(model);
 
-   return {std::move(entry), std::move(scopedEntry)};
+   return {std::move(metaEntry), std::move(scopedEntry)};
 }

tree/ntuple/src/RNTupleAttributes.cxx

@@ -117,8 +117,8 @@ void ROOT::Experimental::RNTupleAttributeSetWriter::EndRangeInternal()
    // Get current entry number from the writer and use it as end of entry range
    const auto end = fMainFillContext->GetNEntries();
    fOpenEntry->fRange = RNTupleAttributeRange::FromStartEnd(fOpenEntry->fRange.Start(), end);
-   auto pRangeStart = fOpenEntry->fEntry->GetPtr<ROOT::NTupleSize_t>("__rangeStart");
-   auto pRangeLen = fOpenEntry->fEntry->GetPtr<ROOT::NTupleSize_t>("__rangeLen");
+   auto pRangeStart = fOpenEntry->fMetaEntry->GetPtr<ROOT::NTupleSize_t>("__rangeStart");
+   auto pRangeLen = fOpenEntry->fMetaEntry->GetPtr<ROOT::NTupleSize_t>("__rangeLen");
    R__ASSERT(pRangeStart);
    R__ASSERT(pRangeLen);
    *pRangeStart = fOpenEntry->GetRange().Start();