From abd36c6a645499607379914b06ab9313ae2050d8 Mon Sep 17 00:00:00 2001 From: Jakob Blomer Date: Fri, 1 Aug 2025 15:04:02 +0200 Subject: [PATCH 1/2] [NFC][ntuple][spec] 'leaf' field --> 'plain' field The name 'plain field' should better describe the actual structural role (resp. the absence of a structural role) of these fields. No change to the on-disk data. --- tree/ntuple/doc/BinaryFormatSpecification.md | 27 +++++++++++--------- 1 file changed, 15 insertions(+), 12 deletions(-) diff --git a/tree/ntuple/doc/BinaryFormatSpecification.md b/tree/ntuple/doc/BinaryFormatSpecification.md index 6941622446968..4e3d564db5d17 100644 --- a/tree/ntuple/doc/BinaryFormatSpecification.md +++ b/tree/ntuple/doc/BinaryFormatSpecification.md @@ -374,13 +374,16 @@ The field version and type version are used for schema evolution. The structural role of the field can have one of the following values: -| Value | Structural role | -|----------|--------------------------------------------------------------------------| -| 0x00 | Leaf field in the schema tree | -| 0x01 | The field is the parent of a collection (e.g., a vector) | -| 0x02 | The field is the parent of a record (e.g., a struct) | -| 0x03 | The field is the parent of a variant | -| 0x04 | The field stores objects serialized with the ROOT streamer | +| Value | Structural role | +|----------|---------------------------------------------------------------------------------| +| 0x00 | Plain field in the schema tree that does not carry a particular structural role | +| 0x01 | The field is the parent of a collection (e.g., a vector) | +| 0x02 | The field is the parent of a record (e.g., a struct) | +| 0x03 | The field is the parent of a variant | +| 0x04 | The field stores objects serialized with the ROOT streamer | + +A plain field is either a leaf or a "wrapper field" in the schema tree such as the parent field of an enum data field +(see Section "Mapping of C++ Types to Fields and Columns") The "flags" field can have any of the following bits set: @@ -403,7 +406,7 @@ these columns are alias columns to physical columns attached to the source field The following restrictions apply on field projections: - The source field and the target field must have the same structural role, except for an `RNTupleCardinality` field, which must have a collection field as a source. - - For streamer fields and leaf fields, the type name of the source field and the projected field must be identical. + - For streamer fields and plain fields, the type name of the source field and the projected field must be identical. - Projections involving variants or fixed-size arrays are unsupported. - Projected fields must be on the same schema path of collection fields as the source field. For instance, one can project a vector of structs with floats to individual vectors of floats but cannot @@ -830,7 +833,7 @@ For example, the type name `const pair>` will be ### Fundamental Types -The following fundamental types are stored as `leaf` fields with a single column each. +The following fundamental types are stored as `plain` fields with a single column each. Fundamental C++ types can potentially be stored in multiple possible column types. The possible combinations are marked as `W` in the following table. Additionally, some types allow for reading from certain column types but not to write into them. @@ -923,7 +926,7 @@ The child fields are named `_0`, `_1`, ... #### std::bitset\ -A bitset is stored as a repetitive leaf field with an attached `Bit` column. +A bitset is stored as a repetitive plain field with an attached `Bit` column. The bitset size `N` is stored as repetition parameter in the field metadata. Within the repetition blocks, bits are stored in little-endian order, i.e. the least significant bits come first. @@ -952,13 +955,13 @@ whose principal column is of type `(Split)Index[64|32]` and a child field of typ ### std::atomic\ -Atomic types are stored as a leaf field with a single subfield named `_0`. +Atomic types are stored as a plain field with a single subfield named `_0`. The parent field has no attached columns. The subfield corresponds to the inner type `T`. ### User-defined enums -User-defined enums are stored as a leaf field with a single subfield named `_0`. +User-defined enums are stored as a plain field with a single subfield named `_0`. The parent field has no attached columns. The subfield corresponds to the integer type the underlies the enum. Unscoped and scoped enums are supported as long as the enum has a dictionary. From 0b31cde560078c2afdf37b9084ed8f10c415a52e Mon Sep 17 00:00:00 2001 From: Jakob Blomer Date: Fri, 1 Aug 2025 14:53:51 +0200 Subject: [PATCH 2/2] [ntuple] ENTupleStructure::kLeaf --> kPlain The structural role "leaf" was ill-named because in the tree of fields also inner nodes can carry that role. Hence renamed to "plain". Plain nodes are either leaves or they are inner "wrapper fields" with exactly one child field of the same cardinality (same number of elements modulo field repetition). --- tree/dataframe/src/RNTupleDS.cxx | 4 +-- tree/ntuple/inc/ROOT/RField.hxx | 6 ++-- tree/ntuple/inc/ROOT/RField/RFieldSTLMisc.hxx | 2 +- tree/ntuple/inc/ROOT/RNTupleTypes.hxx | 17 ++++++---- tree/ntuple/src/RField.cxx | 4 +-- tree/ntuple/src/RFieldMeta.cxx | 4 +-- tree/ntuple/src/RFieldSequenceContainer.cxx | 2 +- tree/ntuple/src/RNTupleMerger.cxx | 2 +- tree/ntuple/src/RNTupleModel.cxx | 4 +-- tree/ntuple/src/RNTupleSerialize.cxx | 6 ++-- tree/ntuple/test/ntuple_descriptor.cxx | 20 +++++------ tree/ntuple/test/ntuple_emulated.cxx | 4 +-- tree/ntuple/test/ntuple_serialize.cxx | 34 +++++++++---------- 13 files changed, 57 insertions(+), 52 deletions(-) diff --git a/tree/dataframe/src/RNTupleDS.cxx b/tree/dataframe/src/RNTupleDS.cxx index 03b76d9f9d297..6b1a1421e59c0 100644 --- a/tree/dataframe/src/RNTupleDS.cxx +++ b/tree/dataframe/src/RNTupleDS.cxx @@ -65,7 +65,7 @@ class RRDFCardinalityField final : public ROOT::RFieldBase { void ConstructValue(void *where) const final { *static_cast(where) = 0; } public: - RRDFCardinalityField() : ROOT::RFieldBase("", "std::size_t", ROOT::ENTupleStructure::kLeaf, false /* isSimple */) {} + RRDFCardinalityField() : ROOT::RFieldBase("", "std::size_t", ROOT::ENTupleStructure::kPlain, false /* isSimple */) {} RRDFCardinalityField(RRDFCardinalityField &&other) = default; RRDFCardinalityField &operator=(RRDFCardinalityField &&other) = default; ~RRDFCardinalityField() override = default; @@ -135,7 +135,7 @@ class RArraySizeField final : public ROOT::RFieldBase { public: RArraySizeField(std::size_t arrayLength) - : ROOT::RFieldBase("", "std::size_t", ROOT::ENTupleStructure::kLeaf, false /* isSimple */), + : ROOT::RFieldBase("", "std::size_t", ROOT::ENTupleStructure::kPlain, false /* isSimple */), fArrayLength(arrayLength) { } diff --git a/tree/ntuple/inc/ROOT/RField.hxx b/tree/ntuple/inc/ROOT/RField.hxx index b342fd6895724..99695ee2d1cc4 100644 --- a/tree/ntuple/inc/ROOT/RField.hxx +++ b/tree/ntuple/inc/ROOT/RField.hxx @@ -97,7 +97,7 @@ protected: public: RInvalidField(std::string_view name, std::string_view type, std::string_view error, ECategory category) - : RFieldBase(name, type, ROOT::ENTupleStructure::kLeaf, false /* isSimple */), fError(error), fCategory(category) + : RFieldBase(name, type, ROOT::ENTupleStructure::kPlain, false /* isSimple */), fError(error), fCategory(category) { fTraits |= kTraitInvalidField; } @@ -326,7 +326,7 @@ private: protected: RCardinalityField(std::string_view fieldName, std::string_view typeName) - : RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kLeaf, false /* isSimple */) + : RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kPlain, false /* isSimple */) { } @@ -355,7 +355,7 @@ protected: void ConstructValue(void *where) const final { new (where) T{0}; } RSimpleField(std::string_view name, std::string_view type) - : RFieldBase(name, type, ROOT::ENTupleStructure::kLeaf, true /* isSimple */) + : RFieldBase(name, type, ROOT::ENTupleStructure::kPlain, true /* isSimple */) { fTraits |= kTraitTrivialType; } diff --git a/tree/ntuple/inc/ROOT/RField/RFieldSTLMisc.hxx b/tree/ntuple/inc/ROOT/RField/RFieldSTLMisc.hxx index 392aab7d29f1d..3453982ca405f 100644 --- a/tree/ntuple/inc/ROOT/RField/RFieldSTLMisc.hxx +++ b/tree/ntuple/inc/ROOT/RField/RFieldSTLMisc.hxx @@ -336,7 +336,7 @@ private: public: static std::string TypeName() { return "std::string"; } explicit RField(std::string_view name) - : RFieldBase(name, TypeName(), ROOT::ENTupleStructure::kLeaf, false /* isSimple */), fIndex(0) + : RFieldBase(name, TypeName(), ROOT::ENTupleStructure::kPlain, false /* isSimple */), fIndex(0) { } RField(RField &&other) = default; diff --git a/tree/ntuple/inc/ROOT/RNTupleTypes.hxx b/tree/ntuple/inc/ROOT/RNTupleTypes.hxx index c33b124048e81..aaad0036532a6 100644 --- a/tree/ntuple/inc/ROOT/RNTupleTypes.hxx +++ b/tree/ntuple/inc/ROOT/RNTupleTypes.hxx @@ -99,23 +99,28 @@ enum class ENTupleColumnType { kMax, }; -/// The fields in the ntuple model tree can carry different structural information about the type system. -/// Leaf fields contain just data, collection fields resolve to offset columns, record fields have no -/// materialization on the primitive column layer. +/// The fields in the RNTuple data model tree can carry different structural information about the type system. +/// Collection fields have an offset column and subfields with arbitrary cardinality, record fields have no +/// materialization on the primitive column layer and an arbitrary number of subfields. Plain fields are either +/// leafs (e.g., `float`) or "wrapper fields" with exactly one child that has the same cardinality +/// (number of elements in the data set modulo field repetitions) as the parent (e.g., std::atomic). // IMPORTANT: if you add members, remember to change the related `operator<<` below. enum class ENTupleStructure : std::uint16_t { kInvalid, - kLeaf, + kPlain, kCollection, kRecord, kVariant, kStreamer, - kUnknown + kUnknown, + + // for backwards compatibility + kLeaf R__DEPRECATED(6, 42, "use instead ROOT::ENTupleStructure::kPlain") = kPlain }; inline std::ostream &operator<<(std::ostream &os, ENTupleStructure structure) { - static const char *const names[] = {"Invalid", "Leaf", "Collection", "Record", "Variant", "Streamer", "Unknown"}; + static const char *const names[] = {"Invalid", "Plain", "Collection", "Record", "Variant", "Streamer", "Unknown"}; static_assert((std::size_t)ENTupleStructure::kUnknown + 1 == std::size(names)); if (R__likely(static_cast(structure) <= std::size(names))) diff --git a/tree/ntuple/src/RField.cxx b/tree/ntuple/src/RField.cxx index 8e0e104f34357..0d48e48f5b951 100644 --- a/tree/ntuple/src/RField.cxx +++ b/tree/ntuple/src/RField.cxx @@ -634,7 +634,7 @@ void ROOT::RRecordField::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) con //------------------------------------------------------------------------------ ROOT::RBitsetField::RBitsetField(std::string_view fieldName, std::size_t N) - : ROOT::RFieldBase(fieldName, "std::bitset<" + std::to_string(N) + ">", ROOT::ENTupleStructure::kLeaf, + : ROOT::RFieldBase(fieldName, "std::bitset<" + std::to_string(N) + ">", ROOT::ENTupleStructure::kPlain, false /* isSimple */, N), fN(N) { @@ -981,7 +981,7 @@ size_t ROOT::ROptionalField::GetAlignment() const ROOT::RAtomicField::RAtomicField(std::string_view fieldName, std::string_view typeName, std::unique_ptr itemField) - : RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kLeaf, false /* isSimple */) + : RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kPlain, false /* isSimple */) { if (itemField->GetTraits() & kTraitTriviallyConstructible) fTraits |= kTraitTriviallyConstructible; diff --git a/tree/ntuple/src/RFieldMeta.cxx b/tree/ntuple/src/RFieldMeta.cxx index f42b445ce9739..9f52fcaf32917 100644 --- a/tree/ntuple/src/RFieldMeta.cxx +++ b/tree/ntuple/src/RFieldMeta.cxx @@ -524,7 +524,7 @@ ROOT::REnumField::REnumField(std::string_view fieldName, std::string_view enumNa } ROOT::REnumField::REnumField(std::string_view fieldName, TEnum *enump) - : ROOT::RFieldBase(fieldName, GetRenormalizedTypeName(enump->GetQualifiedName()), ROOT::ENTupleStructure::kLeaf, + : ROOT::RFieldBase(fieldName, GetRenormalizedTypeName(enump->GetQualifiedName()), ROOT::ENTupleStructure::kPlain, false /* isSimple */) { // Avoid accidentally supporting std types through TEnum. @@ -551,7 +551,7 @@ ROOT::REnumField::REnumField(std::string_view fieldName, TEnum *enump) ROOT::REnumField::REnumField(std::string_view fieldName, std::string_view enumName, std::unique_ptr intField) - : ROOT::RFieldBase(fieldName, enumName, ROOT::ENTupleStructure::kLeaf, false /* isSimple */) + : ROOT::RFieldBase(fieldName, enumName, ROOT::ENTupleStructure::kPlain, false /* isSimple */) { Attach(std::move(intField)); fTraits |= kTraitTriviallyConstructible | kTraitTriviallyDestructible; diff --git a/tree/ntuple/src/RFieldSequenceContainer.cxx b/tree/ntuple/src/RFieldSequenceContainer.cxx index b0aaaebf6bf5c..2d3cdce6ddc70 100644 --- a/tree/ntuple/src/RFieldSequenceContainer.cxx +++ b/tree/ntuple/src/RFieldSequenceContainer.cxx @@ -17,7 +17,7 @@ ROOT::RArrayField::RArrayField(std::string_view fieldName, std::unique_ptrGetTypeName() + "," + Internal::GetNormalizedInteger(static_cast(arrayLength)) + ">", - ROOT::ENTupleStructure::kLeaf, false /* isSimple */, arrayLength), + ROOT::ENTupleStructure::kPlain, false /* isSimple */, arrayLength), fItemSize(itemField->GetValueSize()), fArrayLength(arrayLength) { diff --git a/tree/ntuple/src/RNTupleMerger.cxx b/tree/ntuple/src/RNTupleMerger.cxx index b64f291a576fd..217d093c98c01 100644 --- a/tree/ntuple/src/RNTupleMerger.cxx +++ b/tree/ntuple/src/RNTupleMerger.cxx @@ -700,7 +700,7 @@ GenerateZeroPagesForColumns(size_t nEntriesToGenerate, std::span(target)); if (!hasCompatibleStructure) return R__FAIL("field mapping structural mismatch: " + source->GetFieldName() + " --> " + target->GetFieldName()); - if ((source->GetStructure() == ROOT::ENTupleStructure::kLeaf) || + if ((source->GetStructure() == ROOT::ENTupleStructure::kPlain) || (source->GetStructure() == ROOT::ENTupleStructure::kStreamer)) { if (target->GetTypeName() != source->GetTypeName()) return R__FAIL("field mapping type mismatch: " + source->GetFieldName() + " --> " + target->GetFieldName()); @@ -100,7 +100,7 @@ ROOT::Internal::RProjectedFields::EnsureValidMapping(const ROOT::RFieldBase *tar auto parent = f->GetParent(); while (parent) { if ((parent->GetStructure() != ROOT::ENTupleStructure::kRecord) && - (parent->GetStructure() != ROOT::ENTupleStructure::kLeaf)) { + (parent->GetStructure() != ROOT::ENTupleStructure::kPlain)) { return parent; } parent = parent->GetParent(); diff --git a/tree/ntuple/src/RNTupleSerialize.cxx b/tree/ntuple/src/RNTupleSerialize.cxx index 993d450688e79..f6caa493e9a67 100644 --- a/tree/ntuple/src/RNTupleSerialize.cxx +++ b/tree/ntuple/src/RNTupleSerialize.cxx @@ -149,7 +149,7 @@ DeserializeField(const void *buffer, std::uint64_t bufSize, ROOT::Internal::RFie std::uint32_t typeVersion; std::uint32_t parentId; // initialize properly for call to SerializeFieldStructure() - ENTupleStructure structure{ENTupleStructure::kLeaf}; + ENTupleStructure structure{ENTupleStructure::kPlain}; std::uint16_t flags; std::uint32_t result; if (auto res = RNTupleSerializer::SerializeFieldStructure(structure, nullptr)) { @@ -811,7 +811,7 @@ ROOT::Internal::RNTupleSerializer::SerializeFieldStructure(ROOT::ENTupleStructur { using ENTupleStructure = ROOT::ENTupleStructure; switch (structure) { - case ENTupleStructure::kLeaf: return SerializeUInt16(0x00, buffer); + case ENTupleStructure::kPlain: return SerializeUInt16(0x00, buffer); case ENTupleStructure::kCollection: return SerializeUInt16(0x01, buffer); case ENTupleStructure::kRecord: return SerializeUInt16(0x02, buffer); case ENTupleStructure::kVariant: return SerializeUInt16(0x03, buffer); @@ -830,7 +830,7 @@ ROOT::Internal::RNTupleSerializer::DeserializeFieldStructure(const void *buffer, std::uint16_t onDiskValue; auto result = DeserializeUInt16(buffer, onDiskValue); switch (onDiskValue) { - case 0x00: structure = ENTupleStructure::kLeaf; break; + case 0x00: structure = ENTupleStructure::kPlain; break; case 0x01: structure = ENTupleStructure::kCollection; break; case 0x02: structure = ENTupleStructure::kRecord; break; case 0x03: structure = ENTupleStructure::kVariant; break; diff --git a/tree/ntuple/test/ntuple_descriptor.cxx b/tree/ntuple/test/ntuple_descriptor.cxx index 99f9da692489e..b195bf2a04460 100644 --- a/tree/ntuple/test/ntuple_descriptor.cxx +++ b/tree/ntuple/test/ntuple_descriptor.cxx @@ -41,7 +41,7 @@ TEST(RNTupleDescriptorBuilder, CatchBadLinks) .FieldId(1) .FieldName("field") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); try { @@ -70,21 +70,21 @@ TEST(RNTupleDescriptorBuilder, CatchBadProjections) .FieldId(1) .FieldName("field") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddField(RFieldDescriptorBuilder() .FieldId(2) .FieldName("projField") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddField(RFieldDescriptorBuilder() .FieldId(3) .FieldName("projField") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); @@ -131,14 +131,14 @@ TEST(RNTupleDescriptorBuilder, CatchBadColumnDescriptors) .FieldId(1) .FieldName("field") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddField(RFieldDescriptorBuilder() .FieldId(2) .FieldName("fieldAlias") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddFieldLink(0, 1); @@ -213,7 +213,7 @@ TEST(RFieldDescriptorBuilder, HeaderExtension) .FieldId(1) .FieldName("i32") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddColumn(RColumnDescriptorBuilder() @@ -241,7 +241,7 @@ TEST(RFieldDescriptorBuilder, HeaderExtension) .FieldId(3) .FieldName("i64") .TypeName("int64_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddColumn(RColumnDescriptorBuilder() @@ -260,7 +260,7 @@ TEST(RFieldDescriptorBuilder, HeaderExtension) .FieldId(4) .FieldName("topLevel2") .TypeName("bool") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddColumn(RColumnDescriptorBuilder() @@ -278,7 +278,7 @@ TEST(RFieldDescriptorBuilder, HeaderExtension) .FieldId(5) .FieldName("projected") .TypeName("int64_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); descBuilder.AddColumn(RColumnDescriptorBuilder() diff --git a/tree/ntuple/test/ntuple_emulated.cxx b/tree/ntuple/test/ntuple_emulated.cxx index 372d8b584252b..3607c43cba174 100644 --- a/tree/ntuple/test/ntuple_emulated.cxx +++ b/tree/ntuple/test/ntuple_emulated.cxx @@ -273,7 +273,7 @@ TEST(RNTupleEmulated, EmulatedFields_VecsTemplatedWrapper) const auto *innerField = wrapperField->GetConstSubfields()[0]; ASSERT_EQ(innerField->GetTypeName(), "float"); ASSERT_EQ(innerField->GetFieldName(), "fValue"); - ASSERT_EQ(innerField->GetStructure(), ROOT::ENTupleStructure::kLeaf); + ASSERT_EQ(innerField->GetStructure(), ROOT::ENTupleStructure::kPlain); } // Now test loading entries with a reader @@ -620,7 +620,7 @@ TEST(RNTupleEmulated, CollectionProxy) template <> struct IsCollectionProxy> : std::true_type { }; - } // namespace ROOT + } // namespace ROOT SimpleCollectionProxyForEmuTest> proxyC; auto klassC = TClass::GetClass("StructWithCollectionProxyForEmuTest"); diff --git a/tree/ntuple/test/ntuple_serialize.cxx b/tree/ntuple/test/ntuple_serialize.cxx index 589078cfce6a0..ffa0afea6adab 100644 --- a/tree/ntuple/test/ntuple_serialize.cxx +++ b/tree/ntuple/test/ntuple_serialize.cxx @@ -563,13 +563,13 @@ TEST(RNTuple, SerializeHeader) builder.AddField(RFieldDescriptorBuilder() .FieldId(42) .FieldName("pt") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddField(RFieldDescriptorBuilder() .FieldId(24) .FieldName("ptAlias") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .ProjectionSourceId(42) .MakeDescriptor() .Unwrap()); @@ -582,7 +582,7 @@ TEST(RNTuple, SerializeHeader) builder.AddField(RFieldDescriptorBuilder() .FieldId(13) .FieldName("eta") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 42); @@ -662,7 +662,7 @@ TEST(RNTuple, SerializeFooter) builder.AddField(RFieldDescriptorBuilder() .FieldId(42) .FieldName("tag") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 42); @@ -787,7 +787,7 @@ TEST(RNTuple, SerializeFooterXHeader) .FieldId(42) .FieldName("field") .TypeName("int32_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 42); @@ -817,14 +817,14 @@ TEST(RNTuple, SerializeFooterXHeader) .FieldId(44) .FieldName("f") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddField(RFieldDescriptorBuilder() .FieldId(45) .FieldName("i64") .TypeName("int64_t") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 43); @@ -855,7 +855,7 @@ TEST(RNTuple, SerializeFooterXHeader) .FieldId(46) .FieldName("projected") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 46); @@ -960,7 +960,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentation) .FieldId(7) .FieldName("str") .TypeName("std::string") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 7); @@ -1154,7 +1154,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentationProjection) .FieldId(5) .FieldName("pt") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 5); @@ -1162,7 +1162,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentationProjection) .FieldId(7) .FieldName("ptAlias") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 7); @@ -1305,7 +1305,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentationDeferred) .FieldId(5) .FieldName("pt") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 5); @@ -1425,7 +1425,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentationIncremental) .FieldId(5) .FieldName("pt") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 5); @@ -1549,7 +1549,7 @@ TEST(RNTuple, DeserializeDescriptorModes) .FieldId(1) .FieldName("suppressed") .TypeName("int") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 1); @@ -1601,7 +1601,7 @@ TEST(RNTuple, DeserializeDescriptorModes) .FieldId(2) .FieldName("deferred") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 2); @@ -1822,7 +1822,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentationDeferred_HeaderExtBeforeSerializ .FieldId(5) .FieldName("pt") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 5); @@ -1951,7 +1951,7 @@ TEST(RNTuple, SerializeMultiColumnRepresentationDeferredInMainHeader) .FieldId(5) .FieldName("pt") .TypeName("float") - .Structure(ROOT::ENTupleStructure::kLeaf) + .Structure(ROOT::ENTupleStructure::kPlain) .MakeDescriptor() .Unwrap()); builder.AddFieldLink(0, 5);