Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RNTupleSerialize.hxx
Go to the documentation of this file.
1/// \file ROOT/RNTupleSerialize.hxx
2/// \ingroup NTuple ROOT7
3/// \author Jakob Blomer <jblomer@cern.ch>
4/// \author Javier Lopez-Gomez <javier.lopez.gomez@cern.ch>
5/// \date 2021-08-02
6/// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback
7/// is welcome!
8
9/*************************************************************************
10 * Copyright (C) 1995-2021, Rene Brun and Fons Rademakers. *
11 * All rights reserved. *
12 * *
13 * For the licensing terms see $ROOTSYS/LICENSE. *
14 * For the list of contributors see $ROOTSYS/README/CREDITS. *
15 *************************************************************************/
16
17#ifndef ROOT7_RNTupleSerialize
18#define ROOT7_RNTupleSerialize
19
20#include <ROOT/RError.hxx>
21#include <ROOT/RNTupleUtil.hxx>
22#include <ROOT/RSpan.hxx>
23
24#include <Rtypes.h>
25
26#include <cstdint>
27#include <limits>
28#include <map>
29#include <string>
30#include <unordered_map>
31#include <vector>
32
34
35namespace ROOT {
36namespace Experimental {
37
38enum class EColumnType;
39enum class EExtraTypeInfoIds;
40class RClusterDescriptor;
41class RNTupleDescriptor;
42
43namespace Internal {
44
45class RClusterDescriptorBuilder;
46class RNTupleDescriptorBuilder;
47
48// clang-format off
49/**
50\class ROOT::Experimental::Internal::RNTupleSerializer
51\ingroup NTuple
52\brief A helper class for serializing and deserialization of the RNTuple binary format
53
54All serialization and deserialization routines return the number of bytes processed (written or read).
55
56The serialization routines can be called with a nullptr buffer, in which case only the size required to perform
57a serialization is returned. Deserialization routines must be called with a buffer that is sufficiently large.
58
59Deserialization errors throw exceptions. Only when indicated or when passed as a parameter is the buffer size checked.
60*/
61// clang-format on
63public:
64 static constexpr std::uint16_t kEnvelopeTypeHeader = 0x01;
65 static constexpr std::uint16_t kEnvelopeTypeFooter = 0x02;
66 static constexpr std::uint16_t kEnvelopeTypePageList = 0x03;
67
68 static constexpr std::uint16_t kFlagRepetitiveField = 0x01;
69 static constexpr std::uint16_t kFlagProjectedField = 0x02;
70 static constexpr std::uint16_t kFlagHasTypeChecksum = 0x04;
71
72 static constexpr std::uint16_t kFlagDeferredColumn = 0x08;
73 static constexpr std::uint16_t kFlagHasValueRange = 0x10;
74
75 static constexpr DescriptorId_t kZeroFieldId = std::uint64_t(-2);
76
77 static constexpr int64_t kSuppressedColumnMarker = std::numeric_limits<std::int64_t>::min();
78
79 // In the page sink and the unsplit field, the seen streamer infos are stored in a map
80 // with the unique streamer info number being the key. Sorted by unique number.
81 using StreamerInfoMap_t = std::map<Int_t, TVirtualStreamerInfo *>;
82
84 std::uint64_t fLength = 0;
86 };
87
89 std::uint64_t fFirstEntry = 0;
90 std::uint64_t fNEntries = 0;
91 std::uint8_t fFlags = 0;
92 };
93
95 std::uint64_t fMinEntry = 0;
96 std::uint64_t fEntrySpan = 0;
97 std::uint32_t fNClusters = 0;
99 };
100
101 /// The serialization context is used for the piecewise serialization of a descriptor. During header serialization,
102 /// the mapping of in-memory field and column IDs to on-disk IDs is built so that it can be used for the
103 /// footer serialization in a second step.
104 class RContext {
105 private:
106 std::uint64_t fHeaderSize = 0;
107 std::uint64_t fHeaderXxHash3 = 0;
108 std::map<DescriptorId_t, DescriptorId_t> fMem2OnDiskFieldIDs;
109 std::map<DescriptorId_t, DescriptorId_t> fMem2OnDiskColumnIDs;
110 std::map<DescriptorId_t, DescriptorId_t> fMem2OnDiskClusterIDs;
111 std::map<DescriptorId_t, DescriptorId_t> fMem2OnDiskClusterGroupIDs;
112 std::vector<DescriptorId_t> fOnDisk2MemFieldIDs;
113 std::vector<DescriptorId_t> fOnDisk2MemColumnIDs;
114 std::vector<DescriptorId_t> fOnDisk2MemClusterIDs;
115 std::vector<DescriptorId_t> fOnDisk2MemClusterGroupIDs;
116 std::size_t fHeaderExtensionOffset = -1U;
117
118 public:
119 void SetHeaderSize(std::uint64_t size) { fHeaderSize = size; }
120 std::uint64_t GetHeaderSize() const { return fHeaderSize; }
121 void SetHeaderXxHash3(std::uint64_t xxhash3) { fHeaderXxHash3 = xxhash3; }
122 std::uint64_t GetHeaderXxHash3() const { return fHeaderXxHash3; }
123 /// Map an in-memory field ID to its on-disk counterpart. It is allowed to call this function multiple times for
124 /// the same `memId`, in which case the return value is the on-disk ID assigned on the first call.
126 auto onDiskId = fOnDisk2MemFieldIDs.size();
127 const auto &p = fMem2OnDiskFieldIDs.try_emplace(memId, onDiskId);
128 if (p.second)
129 fOnDisk2MemFieldIDs.push_back(memId);
130 return (*p.first).second;
131 }
132 /// Map an in-memory column ID to its on-disk counterpart. It is allowed to call this function multiple times for
133 /// the same `memId`, in which case the return value is the on-disk ID assigned on the first call.
135 auto onDiskId = fOnDisk2MemColumnIDs.size();
136 const auto &p = fMem2OnDiskColumnIDs.try_emplace(memId, onDiskId);
137 if (p.second)
138 fOnDisk2MemColumnIDs.push_back(memId);
139 return (*p.first).second;
140 }
142 auto onDiskId = fOnDisk2MemClusterIDs.size();
143 fMem2OnDiskClusterIDs[memId] = onDiskId;
144 fOnDisk2MemClusterIDs.push_back(memId);
145 return onDiskId;
146 }
148 {
149 auto onDiskId = fOnDisk2MemClusterGroupIDs.size();
150 fMem2OnDiskClusterGroupIDs[memId] = onDiskId;
151 fOnDisk2MemClusterGroupIDs.push_back(memId);
152 return onDiskId;
153 }
154 /// Map in-memory field and column IDs to their on-disk counterparts. This function is unconditionally called
155 /// during header serialization. This function must be manually called after an incremental schema update as page
156 /// list serialization requires all columns to be mapped.
157 void MapSchema(const RNTupleDescriptor &desc, bool forHeaderExtension);
158
163 {
164 return fMem2OnDiskClusterGroupIDs.at(memId);
165 }
170 {
171 return fOnDisk2MemClusterGroupIDs[onDiskId];
172 }
173
174 /// Return a vector containing the in-memory field ID for each on-disk counterpart, in order, i.e. the `i`-th
175 /// value corresponds to the in-memory field ID for `i`-th on-disk ID
176 const std::vector<DescriptorId_t> &GetOnDiskFieldList() const { return fOnDisk2MemFieldIDs; }
177 /// Mark the first on-disk field ID that is part of the schema extension
179 /// Return the offset of the first element in `fOnDisk2MemFieldIDs` that is part of the schema extension
180 std::size_t GetHeaderExtensionOffset() const { return fHeaderExtensionOffset; }
181 };
182
183 /// Writes a XxHash-3 64bit checksum of the byte range given by data and length.
184 static std::uint32_t
185 SerializeXxHash3(const unsigned char *data, std::uint64_t length, std::uint64_t &xxhash3, void *buffer);
186 /// Expects an xxhash3 checksum in the 8 bytes following data + length and verifies it.
187 static RResult<void> VerifyXxHash3(const unsigned char *data, std::uint64_t length, std::uint64_t &xxhash3);
188 static RResult<void> VerifyXxHash3(const unsigned char *data, std::uint64_t length);
189
190 static std::uint32_t SerializeInt16(std::int16_t val, void *buffer);
191 static std::uint32_t DeserializeInt16(const void *buffer, std::int16_t &val);
192 static std::uint32_t SerializeUInt16(std::uint16_t val, void *buffer);
193 static std::uint32_t DeserializeUInt16(const void *buffer, std::uint16_t &val);
194
195 static std::uint32_t SerializeInt32(std::int32_t val, void *buffer);
196 static std::uint32_t DeserializeInt32(const void *buffer, std::int32_t &val);
197 static std::uint32_t SerializeUInt32(std::uint32_t val, void *buffer);
198 static std::uint32_t DeserializeUInt32(const void *buffer, std::uint32_t &val);
199
200 static std::uint32_t SerializeInt64(std::int64_t val, void *buffer);
201 static std::uint32_t DeserializeInt64(const void *buffer, std::int64_t &val);
202 static std::uint32_t SerializeUInt64(std::uint64_t val, void *buffer);
203 static std::uint32_t DeserializeUInt64(const void *buffer, std::uint64_t &val);
204
205 static std::uint32_t SerializeString(const std::string &val, void *buffer);
206 static RResult<std::uint32_t> DeserializeString(const void *buffer, std::uint64_t bufSize, std::string &val);
207
208 /// While we could just interpret the enums as ints, we make the translation explicit
209 /// in order to avoid accidentally changing the on-disk numbers when adjusting the enum classes.
210 static std::uint32_t SerializeFieldStructure(ROOT::Experimental::ENTupleStructure structure, void *buffer);
211 static std::uint32_t SerializeColumnType(ROOT::Experimental::EColumnType type, void *buffer);
212 static std::uint32_t SerializeExtraTypeInfoId(ROOT::Experimental::EExtraTypeInfoIds id, void *buffer);
218
219 static std::uint32_t SerializeEnvelopePreamble(std::uint16_t envelopeType, void *buffer);
220 static std::uint32_t SerializeEnvelopePostscript(unsigned char *envelope, std::uint64_t size);
221 static std::uint32_t
222 SerializeEnvelopePostscript(unsigned char *envelope, std::uint64_t size, std::uint64_t &xxhash3);
223 // The bufSize must include the 8 bytes for the final xxhash3 checksum.
225 DeserializeEnvelope(const void *buffer, std::uint64_t bufSize, std::uint16_t expectedType);
227 DeserializeEnvelope(const void *buffer, std::uint64_t bufSize, std::uint16_t expectedType, std::uint64_t &xxhash3);
228
229 static std::uint32_t SerializeRecordFramePreamble(void *buffer);
230 static std::uint32_t SerializeListFramePreamble(std::uint32_t nitems, void *buffer);
231 static std::uint32_t SerializeFramePostscript(void *frame, std::uint64_t size);
233 DeserializeFrameHeader(const void *buffer, std::uint64_t bufSize, std::uint64_t &frameSize, std::uint32_t &nitems);
235 DeserializeFrameHeader(const void *buffer, std::uint64_t bufSize, std::uint64_t &frameSize);
236
237 // An empty flags vector will be serialized as a single, zero feature flag
238 // The most significant bit in every flag is reserved and must _not_ be set
239 static std::uint32_t SerializeFeatureFlags(const std::vector<std::uint64_t> &flags, void *buffer);
241 DeserializeFeatureFlags(const void *buffer, std::uint64_t bufSize, std::vector<std::uint64_t> &flags);
242
243 static std::uint32_t SerializeLocator(const RNTupleLocator &locator, void *buffer);
244 static std::uint32_t SerializeEnvelopeLink(const REnvelopeLink &envelopeLink, void *buffer);
245 static RResult<std::uint32_t> DeserializeLocator(const void *buffer, std::uint64_t bufSize, RNTupleLocator &locator);
247 DeserializeEnvelopeLink(const void *buffer, std::uint64_t bufSize, REnvelopeLink &envelopeLink);
248
249 static std::uint32_t SerializeClusterSummary(const RClusterSummary &clusterSummary, void *buffer);
250 static std::uint32_t SerializeClusterGroup(const RClusterGroup &clusterGroup, void *buffer);
252 DeserializeClusterSummary(const void *buffer, std::uint64_t bufSize, RClusterSummary &clusterSummary);
254 DeserializeClusterGroup(const void *buffer, std::uint64_t bufSize, RClusterGroup &clusterGroup);
255
256 /// Serialize the schema description in `desc` into `buffer`. If `forHeaderExtension` is true, serialize only the
257 /// fields and columns tagged as part of the header extension (see `RNTupleDescriptorBuilder::BeginHeaderExtension`).
258 static std::uint32_t SerializeSchemaDescription(void *buffer, const RNTupleDescriptor &desc, const RContext &context,
259 bool forHeaderExtension = false);
261 DeserializeSchemaDescription(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder);
262
263 static RContext SerializeHeader(void *buffer, const RNTupleDescriptor &desc);
264 static std::uint32_t SerializePageList(void *buffer, const RNTupleDescriptor &desc,
265 std::span<DescriptorId_t> physClusterIDs, const RContext &context);
266 static std::uint32_t SerializeFooter(void *buffer, const RNTupleDescriptor &desc, const RContext &context);
267
268 static RResult<void>
269 DeserializeHeader(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder);
270 static RResult<void>
271 DeserializeFooter(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder);
272 // The clusters vector must be initialized with the cluster summaries corresponding to the page list
273 static RResult<void> DeserializePageList(const void *buffer, std::uint64_t bufSize, DescriptorId_t clusterGroupId,
274 RNTupleDescriptor &desc);
275
276 // Helper functions to (de-)serialize the streamer info type extra information
277 static std::string SerializeStreamerInfos(const StreamerInfoMap_t &infos);
278 static RResult<StreamerInfoMap_t> DeserializeStreamerInfos(const std::string &extraTypeInfoContent);
279}; // class RNTupleSerializer
280
281} // namespace Internal
282} // namespace Experimental
283} // namespace ROOT
284
285#endif // ROOT7_RNTupleSerialize
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
winID h TVirtualViewer3D TVirtualGLPainter p
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void data
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h length
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t nitems
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
The available trivial, native content types of a column.
A helper class for piece-wise construction of an RNTupleDescriptor.
The serialization context is used for the piecewise serialization of a descriptor.
DescriptorId_t GetOnDiskColumnId(DescriptorId_t memId) const
const std::vector< DescriptorId_t > & GetOnDiskFieldList() const
Return a vector containing the in-memory field ID for each on-disk counterpart, in order,...
std::map< DescriptorId_t, DescriptorId_t > fMem2OnDiskClusterIDs
DescriptorId_t GetOnDiskFieldId(DescriptorId_t memId) const
DescriptorId_t GetMemColumnId(DescriptorId_t onDiskId) const
DescriptorId_t MapColumnId(DescriptorId_t memId)
Map an in-memory column ID to its on-disk counterpart.
DescriptorId_t MapFieldId(DescriptorId_t memId)
Map an in-memory field ID to its on-disk counterpart.
DescriptorId_t GetMemFieldId(DescriptorId_t onDiskId) const
std::map< DescriptorId_t, DescriptorId_t > fMem2OnDiskFieldIDs
std::map< DescriptorId_t, DescriptorId_t > fMem2OnDiskColumnIDs
std::size_t GetHeaderExtensionOffset() const
Return the offset of the first element in fOnDisk2MemFieldIDs that is part of the schema extension.
std::map< DescriptorId_t, DescriptorId_t > fMem2OnDiskClusterGroupIDs
DescriptorId_t GetMemClusterGroupId(DescriptorId_t onDiskId) const
DescriptorId_t GetMemClusterId(DescriptorId_t onDiskId) const
DescriptorId_t GetOnDiskClusterGroupId(DescriptorId_t memId) const
DescriptorId_t GetOnDiskClusterId(DescriptorId_t memId) const
void BeginHeaderExtension()
Mark the first on-disk field ID that is part of the schema extension.
void MapSchema(const RNTupleDescriptor &desc, bool forHeaderExtension)
Map in-memory field and column IDs to their on-disk counterparts.
A helper class for serializing and deserialization of the RNTuple binary format.
static std::uint32_t SerializeXxHash3(const unsigned char *data, std::uint64_t length, std::uint64_t &xxhash3, void *buffer)
Writes a XxHash-3 64bit checksum of the byte range given by data and length.
static constexpr std::uint16_t kFlagHasTypeChecksum
static RResult< std::uint32_t > DeserializeClusterSummary(const void *buffer, std::uint64_t bufSize, RClusterSummary &clusterSummary)
static std::uint32_t SerializeListFramePreamble(std::uint32_t nitems, void *buffer)
static constexpr std::uint16_t kFlagDeferredColumn
static constexpr std::uint16_t kEnvelopeTypeHeader
static RResult< std::uint32_t > DeserializeClusterGroup(const void *buffer, std::uint64_t bufSize, RClusterGroup &clusterGroup)
static std::uint32_t SerializeEnvelopePostscript(unsigned char *envelope, std::uint64_t size)
static std::uint32_t SerializeColumnType(ROOT::Experimental::EColumnType type, void *buffer)
static RContext SerializeHeader(void *buffer, const RNTupleDescriptor &desc)
static RResult< std::uint32_t > DeserializeColumnType(const void *buffer, ROOT::Experimental::EColumnType &type)
static std::uint32_t SerializeFeatureFlags(const std::vector< std::uint64_t > &flags, void *buffer)
static RResult< std::uint32_t > DeserializeExtraTypeInfoId(const void *buffer, ROOT::Experimental::EExtraTypeInfoIds &id)
static constexpr std::uint16_t kFlagRepetitiveField
static std::uint32_t DeserializeUInt16(const void *buffer, std::uint16_t &val)
static RResult< void > DeserializeHeader(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder)
static RResult< void > DeserializeFooter(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder)
static std::uint32_t SerializeString(const std::string &val, void *buffer)
static std::string SerializeStreamerInfos(const StreamerInfoMap_t &infos)
static RResult< std::uint32_t > DeserializeFrameHeader(const void *buffer, std::uint64_t bufSize, std::uint64_t &frameSize, std::uint32_t &nitems)
static std::uint32_t SerializePageList(void *buffer, const RNTupleDescriptor &desc, std::span< DescriptorId_t > physClusterIDs, const RContext &context)
static std::uint32_t DeserializeUInt32(const void *buffer, std::uint32_t &val)
static std::uint32_t SerializeUInt64(std::uint64_t val, void *buffer)
static std::uint32_t SerializeEnvelopePreamble(std::uint16_t envelopeType, void *buffer)
static std::uint32_t DeserializeInt16(const void *buffer, std::int16_t &val)
static RResult< std::uint32_t > DeserializeFieldStructure(const void *buffer, ROOT::Experimental::ENTupleStructure &structure)
static std::uint32_t SerializeClusterSummary(const RClusterSummary &clusterSummary, void *buffer)
static RResult< StreamerInfoMap_t > DeserializeStreamerInfos(const std::string &extraTypeInfoContent)
static constexpr std::uint16_t kFlagProjectedField
static std::uint32_t SerializeFramePostscript(void *frame, std::uint64_t size)
static std::uint32_t SerializeInt16(std::int16_t val, void *buffer)
static RResult< void > DeserializePageList(const void *buffer, std::uint64_t bufSize, DescriptorId_t clusterGroupId, RNTupleDescriptor &desc)
static std::uint32_t SerializeFieldStructure(ROOT::Experimental::ENTupleStructure structure, void *buffer)
While we could just interpret the enums as ints, we make the translation explicit in order to avoid a...
static std::uint32_t SerializeSchemaDescription(void *buffer, const RNTupleDescriptor &desc, const RContext &context, bool forHeaderExtension=false)
Serialize the schema description in desc into buffer.
static constexpr std::uint16_t kFlagHasValueRange
static RResult< std::uint32_t > DeserializeSchemaDescription(const void *buffer, std::uint64_t bufSize, RNTupleDescriptorBuilder &descBuilder)
std::map< Int_t, TVirtualStreamerInfo * > StreamerInfoMap_t
static std::uint32_t SerializeLocator(const RNTupleLocator &locator, void *buffer)
static std::uint32_t SerializeInt32(std::int32_t val, void *buffer)
static constexpr std::uint16_t kEnvelopeTypePageList
static RResult< void > VerifyXxHash3(const unsigned char *data, std::uint64_t length, std::uint64_t &xxhash3)
Expects an xxhash3 checksum in the 8 bytes following data + length and verifies it.
static std::uint32_t DeserializeUInt64(const void *buffer, std::uint64_t &val)
static RResult< std::uint32_t > DeserializeFeatureFlags(const void *buffer, std::uint64_t bufSize, std::vector< std::uint64_t > &flags)
static std::uint32_t DeserializeInt32(const void *buffer, std::int32_t &val)
static std::uint32_t DeserializeInt64(const void *buffer, std::int64_t &val)
static std::uint32_t SerializeEnvelopeLink(const REnvelopeLink &envelopeLink, void *buffer)
static RResult< std::uint32_t > DeserializeString(const void *buffer, std::uint64_t bufSize, std::string &val)
static std::uint32_t SerializeRecordFramePreamble(void *buffer)
static std::uint32_t SerializeUInt16(std::uint16_t val, void *buffer)
static constexpr std::uint16_t kEnvelopeTypeFooter
static std::uint32_t SerializeClusterGroup(const RClusterGroup &clusterGroup, void *buffer)
static RResult< std::uint32_t > DeserializeEnvelopeLink(const void *buffer, std::uint64_t bufSize, REnvelopeLink &envelopeLink)
static std::uint32_t SerializeFooter(void *buffer, const RNTupleDescriptor &desc, const RContext &context)
static std::uint32_t SerializeInt64(std::int64_t val, void *buffer)
static RResult< std::uint32_t > DeserializeEnvelope(const void *buffer, std::uint64_t bufSize, std::uint16_t expectedType)
static std::uint32_t SerializeUInt32(std::uint32_t val, void *buffer)
static RResult< std::uint32_t > DeserializeLocator(const void *buffer, std::uint64_t bufSize, RNTupleLocator &locator)
static std::uint32_t SerializeExtraTypeInfoId(ROOT::Experimental::EExtraTypeInfoIds id, void *buffer)
The on-storage meta-data of an ntuple.
The class is used as a return type for operations that can fail; wraps a value of type T or an RError...
Definition RError.hxx:194
Abstract Interface class describing Streamer information for one class.
ENTupleStructure
The fields in the ntuple model tree can carry different structural information about the type system.
std::uint64_t DescriptorId_t
Distriniguishes elements of the same type within a descriptor, e.g. different fields.
EExtraTypeInfoIds
Used in RExtraTypeInfoDescriptor.
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Generic information about the physical location of data.