Logo ROOT  
Reference Guide
RFieldVisitor.cxx
Go to the documentation of this file.
1/// \file RFieldVisitor.cxx
2/// \ingroup NTuple ROOT7
3/// \author Simon Leisibach <simon.leisibach@gmail.com>
4/// \date 2019-06-11
5/// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback
6/// is welcome!
7
8/*************************************************************************
9 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers. *
10 * All rights reserved. *
11 * *
12 * For the licensing terms see $ROOTSYS/LICENSE. *
13 * For the list of contributors see $ROOTSYS/README/CREDITS. *
14 *************************************************************************/
15
16#include <ROOT/RField.hxx>
17#include <ROOT/RFieldValue.hxx>
19#include <ROOT/RNTuple.hxx>
20#include <ROOT/RNTupleUtil.hxx>
21#include <ROOT/RNTupleView.hxx>
22
23#include <cassert>
24#include <iostream>
25#include <sstream>
26#include <string>
27#include <vector>
28
29
30//----------------------------- RPrepareVisitor --------------------------------
31
32
34{
35 auto subFields = field.GetSubFields();
36 for (auto f : subFields) {
37 RPrepareVisitor visitor;
38 f->AcceptVisitor(visitor);
39 fNumFields += visitor.fNumFields;
40 fDeepestLevel = std::max(fDeepestLevel, 1 + visitor.fDeepestLevel);
41 }
42}
43
44
46{
47 VisitField(field);
48 fNumFields--;
49 fDeepestLevel--;
50}
51
52
53//---------------------------- RPrintSchemaVisitor -----------------------------
54
55
57{
58 fDeepestLevel = d;
59}
60
62{
63 fNumFields = n;
64 SetAvailableSpaceForStrings();
65}
66
68{
69 fOutput << fFrameSymbol << ' ';
70
71 std::string key = fTreePrefix;
72 key += "Field " + fFieldNoPrefix + std::to_string(fFieldNo);
73 fOutput << RNTupleFormatter::FitString(key, fAvailableSpaceKeyString);
74 fOutput << " : ";
75
76 std::string value = field.GetName();
77 if (!field.GetType().empty())
78 value += " (" + field.GetType() + ")";
79 fOutput << RNTupleFormatter::FitString(value, fAvailableSpaceValueString);
80 fOutput << fFrameSymbol << std::endl;
81
82 auto subFields = field.GetSubFields();
83 auto fieldNo = 1;
84 for (auto iField = subFields.begin(); iField != subFields.end(); ) {
85 RPrintSchemaVisitor visitor(*this);
86 visitor.fFieldNo = fieldNo++;
87 visitor.fFieldNoPrefix += std::to_string(fFieldNo) + ".";
88
89 auto f = *iField;
90 ++iField;
91 // TODO(jblomer): implement tree drawing
92 visitor.fTreePrefix += " ";
93 f->AcceptVisitor(visitor);
94 }
95}
96
97
99{
100 auto fieldNo = 1;
101 for (auto f : fieldZero.GetSubFields()) {
102 RPrintSchemaVisitor visitor(*this);
103 visitor.fFieldNo = fieldNo++;
104 f->AcceptVisitor(visitor);
105 }
106}
107
108
109//--------------------------- RPrintValueVisitor -------------------------------
110
112{
113 if (fPrintOptions.fPrintSingleLine)
114 return;
115
116 for (unsigned int i = 0; i < fLevel; ++i)
117 fOutput << " ";
118}
119
120
122{
123 if (fPrintOptions.fPrintName)
124 fOutput << "\"" << field.GetName() << "\": ";
125}
126
127
129{
130 PrintIndent();
131 PrintName(field);
132 fOutput << "[";
133 auto elems = field.SplitValue(fValue);
134 for (auto iValue = elems.begin(); iValue != elems.end(); ) {
135 RPrintOptions options;
136 options.fPrintSingleLine = true;
137 options.fPrintName = false;
138 RPrintValueVisitor elemVisitor(*iValue, fOutput, 0 /* level */, options);
139 iValue->GetField()->AcceptVisitor(elemVisitor);
140
141 if (++iValue == elems.end())
142 break;
143 else
144 fOutput << ", ";
145 }
146 fOutput << "]";
147}
148
149
151{
152 PrintIndent();
153 PrintName(field);
154 fOutput << "\"<unsupported type: " << field.GetType() << ">\"";
155}
156
157
159{
160 PrintIndent();
161 PrintName(field);
162 if (*fValue.Get<bool>())
163 fOutput << "true";
164 else
165 fOutput << "false";
166}
167
168
170{
171 PrintIndent();
172 PrintName(field);
173 fOutput << *fValue.Get<double>();
174}
175
176
178{
179 PrintIndent();
180 PrintName(field);
181 fOutput << *fValue.Get<float>();
182}
183
185{
186 PrintIndent();
187 PrintName(field);
188 fOutput << *fValue.Get<char>();
189}
190
192{
193 PrintIndent();
194 PrintName(field);
195 fOutput << *fValue.Get<std::int8_t>();
196}
197
199{
200 PrintIndent();
201 PrintName(field);
202 fOutput << *fValue.Get<std::int16_t>();
203}
204
206{
207 PrintIndent();
208 PrintName(field);
209 fOutput << *fValue.Get<int>();
210}
211
213{
214 PrintIndent();
215 PrintName(field);
216 fOutput << *fValue.Get<std::int64_t>();
217}
218
220{
221 PrintIndent();
222 PrintName(field);
223 // TODO(jblomer): escape double quotes
224 fOutput << "\"" << *fValue.Get<std::string>() << "\"";
225}
226
227
229{
230 PrintIndent();
231 PrintName(field);
232 fOutput << static_cast<int>(*fValue.Get<std::uint8_t>());
233}
234
236{
237 PrintIndent();
238 PrintName(field);
239 fOutput << *fValue.Get<std::uint16_t>();
240}
241
243{
244 PrintIndent();
245 PrintName(field);
246 fOutput << *fValue.Get<std::uint32_t>();
247}
248
249
251{
252 PrintIndent();
253 PrintName(field);
254 fOutput << *fValue.Get<std::uint64_t>();
255}
256
258{
259 PrintIndent();
260 PrintName(field);
261 fOutput << static_cast<std::size_t>(*fValue.Get<RNTupleCardinality>());
262}
263
265{
266 constexpr auto nBitsULong = sizeof(unsigned long) * 8;
267 const auto *asULongArray = fValue.Get<unsigned long>();
268
269 PrintIndent();
270 PrintName(field);
271 fOutput << "\"";
272 std::size_t i = 0;
273 std::string str;
274 for (std::size_t word = 0; word < (field.GetN() + nBitsULong - 1) / nBitsULong; ++word) {
275 for (std::size_t mask = 0; (mask < nBitsULong) && (i < field.GetN()); ++mask, ++i) {
276 bool isSet = (asULongArray[word] & (static_cast<unsigned long>(1) << mask)) != 0;
277 str = std::to_string(isSet) + str;
278 }
279 }
280 fOutput << str << "\"";
281}
282
284{
285 PrintCollection(field);
286}
287
288
290{
291 PrintIndent();
292 PrintName(field);
293 fOutput << "{";
294 auto elems = field.SplitValue(fValue);
295 for (auto iValue = elems.begin(); iValue != elems.end(); ) {
296 if (!fPrintOptions.fPrintSingleLine)
297 fOutput << std::endl;
298
299 RPrintOptions options;
300 options.fPrintSingleLine = fPrintOptions.fPrintSingleLine;
301 RPrintValueVisitor visitor(*iValue, fOutput, fLevel + 1, options);
302 iValue->GetField()->AcceptVisitor(visitor);
303
304 if (++iValue == elems.end()) {
305 if (!fPrintOptions.fPrintSingleLine)
306 fOutput << std::endl;
307 break;
308 } else {
309 fOutput << ",";
310 if (fPrintOptions.fPrintSingleLine)
311 fOutput << " ";
312 }
313 }
314 PrintIndent();
315 fOutput << "}";
316}
317
318
320{
321 PrintIndent();
322 PrintName(field);
323 fOutput << "{";
324 auto elems = field.SplitValue(fValue);
325 for (auto iValue = elems.begin(); iValue != elems.end(); ) {
326 if (!fPrintOptions.fPrintSingleLine)
327 fOutput << std::endl;
328
329 RPrintOptions options;
330 options.fPrintSingleLine = fPrintOptions.fPrintSingleLine;
331 RPrintValueVisitor visitor(*iValue, fOutput, fLevel + 1, options);
332 iValue->GetField()->AcceptVisitor(visitor);
333
334 if (++iValue == elems.end()) {
335 if (!fPrintOptions.fPrintSingleLine)
336 fOutput << std::endl;
337 break;
338 } else {
339 fOutput << ",";
340 if (fPrintOptions.fPrintSingleLine)
341 fOutput << " ";
342 }
343 }
344 PrintIndent();
345 fOutput << "}";
346}
347
349{
350 PrintCollection(field);
351}
352
354{
355 PrintCollection(field);
356}
357
358
360{
361 PrintCollection(field);
362}
363
365{
366 PrintCollection(field);
367}
368
369//---------------------------- RNTupleFormatter --------------------------------
370
371
372std::string ROOT::Experimental::RNTupleFormatter::FitString(const std::string &str, int availableSpace)
373{
374 int strSize{static_cast<int>(str.size())};
375 if (strSize <= availableSpace)
376 return str + std::string(availableSpace - strSize, ' ');
377 else if (availableSpace < 3)
378 return std::string(availableSpace, '.');
379 return std::string(str, 0, availableSpace - 3) + "...";
380}
#define d(i)
Definition: RSha256.hxx:102
#define f(i)
Definition: RSha256.hxx:104
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 mask
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
virtual std::vector< RFieldValue > SplitValue(const RFieldValue &value) const
Creates the list of direct child values given a value for this field.
Definition: RField.cxx:398
std::vector< RFieldBase * > GetSubFields() const
Definition: RField.cxx:411
The generic field for fixed size arrays, which do not need an offset column.
Definition: RField.hxx:688
The generic field an std::bitset<N>.
Definition: RField.hxx:721
std::size_t GetN() const
Get the number of bits in the bitset, i.e. the N in std::bitset<N>
Definition: RField.hxx:761
The field for a class with dictionary.
Definition: RField.hxx:394
std::vector< Detail::RFieldValue > SplitValue(const Detail::RFieldValue &value) const final
Creates the list of direct child values given a value for this field.
Definition: RField.cxx:1183
The field for a class representing a collection of elements via TVirtualCollectionProxy.
Definition: RField.hxx:453
The container field for an ntuple model, which itself has no physical representation.
Definition: RField.hxx:375
An artificial field that transforms an RNTuple column that contains the offset of collections into co...
Definition: RField.hxx:1059
Classes with dictionaries that can be inspected by TClass.
Definition: RField.hxx:805
static std::string FitString(const std::string &str, int availableSpace)
Visitor used for a pre-processing run to collect information needed by another visitor class.
void VisitField(const Detail::RFieldBase &field) final
void VisitFieldZero(const RFieldZero &field) final
Contains settings for printing and prints a summary of an RField instance.
void VisitField(const Detail::RFieldBase &field) final
Prints summary of Field.
void VisitFieldZero(const RFieldZero &fieldZero) final
Renders a JSON value corresponding to the field.
void VisitVectorBoolField(const RField< std::vector< bool > > &field) final
void VisitDoubleField(const RField< double > &field) final
void VisitUInt16Field(const RField< std::uint16_t > &field) final
void VisitCardinalityField(const RField< RNTupleCardinality > &field) final
void VisitArrayField(const RArrayField &field) final
void VisitFloatField(const RField< float > &field) final
void VisitRecordField(const RRecordField &field) final
void VisitStringField(const RField< std::string > &field) final
void VisitInt8Field(const RField< std::int8_t > &field) final
void PrintName(const Detail::RFieldBase &field)
void VisitUInt8Field(const RField< std::uint8_t > &field) final
void VisitBitsetField(const RBitsetField &field) final
void VisitField(const Detail::RFieldBase &field) final
void PrintCollection(const Detail::RFieldBase &field)
void VisitRVecField(const RRVecField &field) final
void VisitUInt64Field(const RField< std::uint64_t > &field) final
void VisitBoolField(const RField< bool > &field) final
void VisitInt16Field(const RField< std::int16_t > &field) final
void VisitVectorField(const RVectorField &field) final
void VisitCharField(const RField< char > &field) final
void VisitCollectionClassField(const RCollectionClassField &field) final
void VisitInt64Field(const RField< std::int64_t > &field) final
void VisitClassField(const RClassField &field) final
void VisitIntField(const RField< int > &field) final
void VisitUInt32Field(const RField< std::uint32_t > &field) final
The type-erased field for a RVec<Type>
Definition: RField.hxx:642
The field for an untyped record.
Definition: RField.hxx:553
std::vector< Detail::RFieldValue > SplitValue(const Detail::RFieldValue &value) const final
Creates the list of direct child values given a value for this field.
Definition: RField.cxx:1498
The generic field for a (nested) std::vector<Type> except for std::vector<bool>
Definition: RField.hxx:605
const Int_t n
Definition: legend1.C:16
Helper type to present an offset column as array of collection sizes. See RField<RNTupleCardinality> ...
Definition: RNTupleUtil.hxx:67