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/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. diff --git a/tree/ntuple/inc/ROOT/RField.hxx b/tree/ntuple/inc/ROOT/RField.hxx index a0243d8dee4c6..08970f1460c6d 100644 --- a/tree/ntuple/inc/ROOT/RField.hxx +++ b/tree/ntuple/inc/ROOT/RField.hxx @@ -95,7 +95,7 @@ protected: public: RInvalidField(std::string_view name, std::string_view type, std::string_view error, RCategory 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; } @@ -324,7 +324,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 */) { } @@ -353,7 +353,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..cd401de85154b 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, 40, "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);