Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
RField.cxx
Go to the documentation of this file.
1/// \file RField.cxx
2/// \ingroup NTuple
3/// \author Jakob Blomer <jblomer@cern.ch>
4/// \date 2018-10-15
5
6/*************************************************************************
7 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers. *
8 * All rights reserved. *
9 * *
10 * For the licensing terms see $ROOTSYS/LICENSE. *
11 * For the list of contributors see $ROOTSYS/README/CREDITS. *
12 *************************************************************************/
13
14#include <ROOT/RColumn.hxx>
15#include <ROOT/REntry.hxx>
16#include <ROOT/RError.hxx>
17#include <ROOT/RField.hxx>
19#include <ROOT/RLogger.hxx>
20#include <ROOT/RNTupleModel.hxx>
22#include <ROOT/RNTupleTypes.hxx>
23
24#include <algorithm>
25#include <cstdint>
26#include <exception>
27#include <functional>
28#include <iostream>
29#include <memory>
30#include <type_traits>
31
32std::unique_ptr<ROOT::RFieldBase> ROOT::RFieldZero::CloneImpl(std::string_view /*newName*/) const
33{
34 auto result = std::make_unique<RFieldZero>();
35 for (auto &f : fSubfields)
36 result->Attach(f->Clone(f->GetFieldName()));
37 return result;
38}
39
41{
42 visitor.VisitFieldZero(*this);
43}
44
45//------------------------------------------------------------------------------
46
56
61
63{
64 visitor.VisitCardinalityField(*this);
65}
66
71
76
77//------------------------------------------------------------------------------
78
79template class ROOT::RSimpleField<char>;
80
100
102{
103 visitor.VisitCharField(*this);
104}
105
106//------------------------------------------------------------------------------
107
108template class ROOT::RSimpleField<std::byte>;
109
111{
112 static RColumnRepresentations representations({{ENTupleColumnType::kByte}}, {});
113 return representations;
114}
115
117{
118 visitor.VisitByteField(*this);
119}
120
121//------------------------------------------------------------------------------
122
123template class ROOT::RSimpleField<int8_t>;
124
126{
127 static RColumnRepresentations representations({{ENTupleColumnType::kInt8}}, {{ENTupleColumnType::kChar},
142 return representations;
143}
144
146{
147 visitor.VisitInt8Field(*this);
148}
149
150//------------------------------------------------------------------------------
151
152template class ROOT::RSimpleField<uint8_t>;
153
155{
156 static RColumnRepresentations representations({{ENTupleColumnType::kUInt8}}, {{ENTupleColumnType::kChar},
171 return representations;
172}
173
175{
176 visitor.VisitUInt8Field(*this);
177}
178
179//------------------------------------------------------------------------------
180
181template class ROOT::RSimpleField<bool>;
182
202
204{
205 visitor.VisitBoolField(*this);
206}
207
208//------------------------------------------------------------------------------
209
210template class ROOT::RSimpleField<float>;
211
222
224{
225 visitor.VisitFloatField(*this);
226}
227
228//------------------------------------------------------------------------------
229
230template class ROOT::RSimpleField<double>;
231
244
246{
247 visitor.VisitDoubleField(*this);
248}
249
251{
252 fTypeAlias = "Double32_t";
253}
254
255//------------------------------------------------------------------------------
256
257template class ROOT::RSimpleField<int16_t>;
258
260{
276 return representations;
277}
278
280{
281 visitor.VisitInt16Field(*this);
282}
283
284//------------------------------------------------------------------------------
285
286template class ROOT::RSimpleField<uint16_t>;
287
289{
305 return representations;
306}
307
309{
310 visitor.VisitUInt16Field(*this);
311}
312
313//------------------------------------------------------------------------------
314
315template class ROOT::RSimpleField<int32_t>;
316
318{
334 return representations;
335}
336
338{
339 visitor.VisitInt32Field(*this);
340}
341
342//------------------------------------------------------------------------------
343
344template class ROOT::RSimpleField<uint32_t>;
345
347{
363 return representations;
364}
365
367{
368 visitor.VisitUInt32Field(*this);
369}
370
371//------------------------------------------------------------------------------
372
373template class ROOT::RSimpleField<uint64_t>;
374
376{
392 return representations;
393}
394
396{
397 visitor.VisitUInt64Field(*this);
398}
399
400//------------------------------------------------------------------------------
401
402template class ROOT::RSimpleField<int64_t>;
403
405{
421 return representations;
422}
423
425{
426 visitor.VisitInt64Field(*this);
427}
428
429//------------------------------------------------------------------------------
430
432{
437 {});
438 return representations;
439}
440
442{
444}
445
447{
449}
450
451std::size_t ROOT::RField<std::string>::AppendImpl(const void *from)
452{
453 auto typedValue = static_cast<const std::string *>(from);
454 auto length = typedValue->length();
455 fAuxiliaryColumn->AppendV(typedValue->data(), length);
456 fIndex += length;
457 fPrincipalColumn->Append(&fIndex);
458 return length + fPrincipalColumn->GetElement()->GetPackedSize();
459}
460
462{
463 auto typedValue = static_cast<std::string *>(to);
464 RNTupleLocalIndex collectionStart;
466 fPrincipalColumn->GetCollectionInfo(globalIndex, &collectionStart, &nChars);
467 if (nChars == 0) {
468 typedValue->clear();
469 } else {
470 typedValue->resize(nChars);
471 fAuxiliaryColumn->ReadV(collectionStart, nChars, const_cast<char *>(typedValue->data()));
472 }
473}
474
476{
477 visitor.VisitStringField(*this);
478}
479
480//------------------------------------------------------------------------------
481
483 : ROOT::RFieldBase(name, source.GetTypeName(), ROOT::ENTupleStructure::kRecord, false /* isSimple */),
484 fMaxAlignment(source.fMaxAlignment),
486 fOffsets(source.fOffsets)
487{
488 for (const auto &f : source.GetConstSubfields())
489 Attach(f->Clone(f->GetFieldName()));
490 fTraits = source.fTraits;
491}
492
493ROOT::RRecordField::RRecordField(std::string_view fieldName, std::string_view typeName)
494 : ROOT::RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kRecord, false /* isSimple */)
495{
496}
497
498void ROOT::RRecordField::AttachItemFields(std::vector<std::unique_ptr<RFieldBase>> itemFields)
499{
500 fTraits |= kTraitTrivialType;
501 for (auto &item : itemFields) {
502 fMaxAlignment = std::max(fMaxAlignment, item->GetAlignment());
503 fSize += GetItemPadding(fSize, item->GetAlignment()) + item->GetValueSize();
504 fTraits &= item->GetTraits();
505 Attach(std::move(item));
506 }
507 // Trailing padding: although this is implementation-dependent, most add enough padding to comply with the
508 // requirements of the type with strictest alignment
509 fSize += GetItemPadding(fSize, fMaxAlignment);
510}
511
512std::unique_ptr<ROOT::RFieldBase>
514 std::vector<std::unique_ptr<RFieldBase>> itemFields,
515 std::string_view emulatedFromType)
516{
517 R__ASSERT(!emulatedFromType.empty());
518 return std::unique_ptr<RFieldBase>(new RRecordField(fieldName, std::move(itemFields), emulatedFromType));
519}
520
521std::unique_ptr<ROOT::RFieldBase> ROOT::Internal::CreateEmulatedVectorField(std::string_view fieldName,
522 std::unique_ptr<RFieldBase> itemField,
523 std::string_view emulatedFromType)
524{
525 R__ASSERT(!emulatedFromType.empty());
526 return std::unique_ptr<RFieldBase>(new RVectorField(fieldName, std::move(itemField), emulatedFromType));
527}
528
529ROOT::RRecordField::RRecordField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields,
530 std::string_view emulatedFromType)
532{
534 fOffsets.reserve(itemFields.size());
535 for (auto &item : itemFields) {
536 fSize += GetItemPadding(fSize, item->GetAlignment());
537 fOffsets.push_back(fSize);
538 fMaxAlignment = std::max(fMaxAlignment, item->GetAlignment());
539 fSize += item->GetValueSize();
540 fTraits &= item->GetTraits();
541 Attach(std::move(item));
542 }
544 // Trailing padding: although this is implementation-dependent, most add enough padding to comply with the
545 // requirements of the type with strictest alignment
547}
548
549ROOT::RRecordField::RRecordField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields)
551{
552}
553
554std::size_t ROOT::RRecordField::GetItemPadding(std::size_t baseOffset, std::size_t itemAlignment) const
555{
556 if (itemAlignment > 1) {
557 auto remainder = baseOffset % itemAlignment;
558 if (remainder != 0)
559 return itemAlignment - remainder;
560 }
561 return 0;
562}
563
564std::unique_ptr<ROOT::RFieldBase> ROOT::RRecordField::CloneImpl(std::string_view newName) const
565{
566 return std::unique_ptr<RRecordField>(new RRecordField(newName, *this));
567}
568
569std::size_t ROOT::RRecordField::AppendImpl(const void *from)
570{
571 std::size_t nbytes = 0;
572 for (unsigned i = 0; i < fSubfields.size(); ++i) {
573 nbytes += CallAppendOn(*fSubfields[i], static_cast<const unsigned char *>(from) + fOffsets[i]);
574 }
575 return nbytes;
576}
577
579{
580 for (unsigned i = 0; i < fSubfields.size(); ++i) {
581 CallReadOn(*fSubfields[i], globalIndex, static_cast<unsigned char *>(to) + fOffsets[i]);
582 }
583}
584
586{
587 for (unsigned i = 0; i < fSubfields.size(); ++i) {
588 CallReadOn(*fSubfields[i], localIndex, static_cast<unsigned char *>(to) + fOffsets[i]);
589 }
590}
591
593{
594 for (unsigned i = 0; i < fSubfields.size(); ++i) {
595 CallConstructValueOn(*fSubfields[i], static_cast<unsigned char *>(where) + fOffsets[i]);
596 }
597}
598
600{
601 for (unsigned i = 0; i < fItemDeleters.size(); ++i) {
602 fItemDeleters[i]->operator()(reinterpret_cast<unsigned char *>(objPtr) + fOffsets[i], true /* dtorOnly */);
603 }
604 RDeleter::operator()(objPtr, dtorOnly);
605}
606
607std::unique_ptr<ROOT::RFieldBase::RDeleter> ROOT::RRecordField::GetDeleter() const
608{
609 std::vector<std::unique_ptr<RDeleter>> itemDeleters;
610 itemDeleters.reserve(fOffsets.size());
611 for (const auto &f : fSubfields) {
612 itemDeleters.emplace_back(GetDeleterOf(*f));
613 }
614 return std::make_unique<RRecordDeleter>(std::move(itemDeleters), fOffsets);
615}
616
617std::vector<ROOT::RFieldBase::RValue> ROOT::RRecordField::SplitValue(const RValue &value) const
618{
619 auto valuePtr = value.GetPtr<void>();
620 auto charPtr = static_cast<unsigned char *>(valuePtr.get());
621 std::vector<RValue> result;
622 result.reserve(fSubfields.size());
623 for (unsigned i = 0; i < fSubfields.size(); ++i) {
624 result.emplace_back(fSubfields[i]->BindValue(std::shared_ptr<void>(valuePtr, charPtr + fOffsets[i])));
625 }
626 return result;
627}
628
630{
631 visitor.VisitRecordField(*this);
632}
633
634//------------------------------------------------------------------------------
635
636ROOT::RBitsetField::RBitsetField(std::string_view fieldName, std::size_t N)
637 : ROOT::RFieldBase(fieldName, "std::bitset<" + std::to_string(N) + ">", ROOT::ENTupleStructure::kPlain,
638 false /* isSimple */, N),
639 fN(N)
640{
642}
643
649
654
659
660template <typename FUlong, typename FUlonglong, typename... Args>
662{
663 if (WordSize() == sizeof(unsigned long)) {
664 fUlong(std::forward<Args>(args)..., fN, *fPrincipalColumn);
665 } else if (WordSize() == sizeof(unsigned long long)) {
666 // NOTE: this can only happen on Windows; see the comment on the RBitsetField class.
667 fUlonglong(std::forward<Args>(args)..., fN, *fPrincipalColumn);
668 } else {
669 R__ASSERT(false);
670 }
671}
672
673template <typename Word_t>
674static void BitsetAppendImpl(const void *from, size_t nBits, ROOT::Internal::RColumn &column)
675{
676 constexpr auto kBitsPerWord = sizeof(Word_t) * 8;
677
678 const auto *asWordArray = static_cast<const Word_t *>(from);
679 bool elementValue;
680 std::size_t i = 0;
681 for (std::size_t word = 0; word < (nBits + kBitsPerWord - 1) / kBitsPerWord; ++word) {
682 for (std::size_t mask = 0; (mask < kBitsPerWord) && (i < nBits); ++mask, ++i) {
683 elementValue = (asWordArray[word] & (static_cast<Word_t>(1) << mask)) != 0;
684 column.Append(&elementValue);
685 }
686 }
687}
688
689std::size_t ROOT::RBitsetField::AppendImpl(const void *from)
690{
692 return fN;
693}
694
695template <typename Word_t>
696static void
698{
699 constexpr auto kBitsPerWord = sizeof(Word_t) * 8;
700
701 auto *asWordArray = static_cast<Word_t *>(to);
702 bool elementValue;
703 for (std::size_t i = 0; i < nBits; ++i) {
704 column.Read(globalIndex * nBits + i, &elementValue);
705 Word_t mask = static_cast<Word_t>(1) << (i % kBitsPerWord);
706 Word_t bit = static_cast<Word_t>(elementValue) << (i % kBitsPerWord);
707 asWordArray[i / kBitsPerWord] = (asWordArray[i / kBitsPerWord] & ~mask) | bit;
708 }
709}
710
715
716template <typename Word_t>
717static void
719{
720 constexpr auto kBitsPerWord = sizeof(Word_t) * 8;
721
722 auto *asWordArray = static_cast<Word_t *>(to);
723 bool elementValue;
724 for (std::size_t i = 0; i < nBits; ++i) {
725 column.Read(ROOT::RNTupleLocalIndex(localIndex.GetClusterId(), localIndex.GetIndexInCluster() * nBits) + i,
726 &elementValue);
727 Word_t mask = static_cast<Word_t>(1) << (i % kBitsPerWord);
728 Word_t bit = static_cast<Word_t>(elementValue) << (i % kBitsPerWord);
729 asWordArray[i / kBitsPerWord] = (asWordArray[i / kBitsPerWord] & ~mask) | bit;
730 }
731}
732
737
739{
740 visitor.VisitBitsetField(*this);
741}
742
743//------------------------------------------------------------------------------
744
745ROOT::RNullableField::RNullableField(std::string_view fieldName, std::string_view typeName,
746 std::unique_ptr<RFieldBase> itemField)
747 : ROOT::RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kCollection, false /* isSimple */)
748{
749 Attach(std::move(itemField));
750}
751
761
766
771
773{
774 fPrincipalColumn->Append(&fNWritten);
775 return sizeof(ROOT::Internal::RColumnIndex);
776}
777
778std::size_t ROOT::RNullableField::AppendValue(const void *from)
779{
780 auto nbytesItem = CallAppendOn(*fSubfields[0], from);
781 fNWritten++;
782 fPrincipalColumn->Append(&fNWritten);
784}
785
793
795{
796 visitor.VisitNullableField(*this);
797}
798
799//------------------------------------------------------------------------------
800
801ROOT::RUniquePtrField::RUniquePtrField(std::string_view fieldName, std::string_view typeName,
802 std::unique_ptr<RFieldBase> itemField)
803 : RNullableField(fieldName, typeName, std::move(itemField)), fItemDeleter(GetDeleterOf(*fSubfields[0]))
804{
805}
806
807std::unique_ptr<ROOT::RFieldBase> ROOT::RUniquePtrField::CloneImpl(std::string_view newName) const
808{
809 auto newItemField = fSubfields[0]->Clone(fSubfields[0]->GetFieldName());
810 return std::make_unique<RUniquePtrField>(newName, GetTypeName(), std::move(newItemField));
811}
812
813std::size_t ROOT::RUniquePtrField::AppendImpl(const void *from)
814{
815 auto typedValue = static_cast<const std::unique_ptr<char> *>(from);
816 if (*typedValue) {
817 return AppendValue(typedValue->get());
818 } else {
819 return AppendNull();
820 }
821}
822
824{
825 auto ptr = static_cast<std::unique_ptr<char> *>(to);
826 bool isValidValue = static_cast<bool>(*ptr);
827
828 auto itemIndex = GetItemIndex(globalIndex);
829 bool isValidItem = itemIndex.GetIndexInCluster() != ROOT::kInvalidNTupleIndex;
830
831 void *valuePtr = nullptr;
832 if (isValidValue)
833 valuePtr = ptr->get();
834
835 if (isValidValue && !isValidItem) {
836 ptr->release();
837 fItemDeleter->operator()(valuePtr, false /* dtorOnly */);
838 return;
839 }
840
841 if (!isValidItem) // On-disk value missing; nothing else to do
842 return;
843
844 if (!isValidValue) {
845 valuePtr = CallCreateObjectRawPtrOn(*fSubfields[0]);
846 ptr->reset(reinterpret_cast<char *>(valuePtr));
847 }
848
849 CallReadOn(*fSubfields[0], itemIndex, valuePtr);
850}
851
853{
854 auto typedPtr = static_cast<std::unique_ptr<char> *>(objPtr);
855 if (*typedPtr) {
856 fItemDeleter->operator()(typedPtr->get(), false /* dtorOnly */);
857 typedPtr->release();
858 }
859 RDeleter::operator()(objPtr, dtorOnly);
860}
861
862std::unique_ptr<ROOT::RFieldBase::RDeleter> ROOT::RUniquePtrField::GetDeleter() const
863{
864 return std::make_unique<RUniquePtrDeleter>(GetDeleterOf(*fSubfields[0]));
865}
866
867std::vector<ROOT::RFieldBase::RValue> ROOT::RUniquePtrField::SplitValue(const RValue &value) const
868{
869 std::vector<RValue> result;
870 auto valuePtr = value.GetPtr<void>();
871 const auto &uniquePtr = *static_cast<std::unique_ptr<char> *>(valuePtr.get());
872 if (uniquePtr) {
873 result.emplace_back(fSubfields[0]->BindValue(std::shared_ptr<void>(valuePtr, uniquePtr.get())));
874 }
875 return result;
876}
877
878//------------------------------------------------------------------------------
879
880ROOT::ROptionalField::ROptionalField(std::string_view fieldName, std::string_view typeName,
881 std::unique_ptr<RFieldBase> itemField)
882 : RNullableField(fieldName, typeName, std::move(itemField)), fItemDeleter(GetDeleterOf(*fSubfields[0]))
883{
886}
887
889{
890 return reinterpret_cast<bool *>(reinterpret_cast<unsigned char *>(optionalPtr) + fSubfields[0]->GetValueSize());
891}
892
894{
895 return GetEngagementPtr(const_cast<void *>(optionalPtr));
896}
897
898std::unique_ptr<ROOT::RFieldBase> ROOT::ROptionalField::CloneImpl(std::string_view newName) const
899{
900 auto newItemField = fSubfields[0]->Clone(fSubfields[0]->GetFieldName());
901 return std::make_unique<ROptionalField>(newName, GetTypeName(), std::move(newItemField));
902}
903
904std::size_t ROOT::ROptionalField::AppendImpl(const void *from)
905{
906 if (*GetEngagementPtr(from)) {
907 return AppendValue(from);
908 } else {
909 return AppendNull();
910 }
911}
912
914{
915 auto engagementPtr = GetEngagementPtr(to);
916 auto itemIndex = GetItemIndex(globalIndex);
917 if (itemIndex.GetIndexInCluster() == ROOT::kInvalidNTupleIndex) {
918 if (*engagementPtr && !(fSubfields[0]->GetTraits() & kTraitTriviallyDestructible))
919 fItemDeleter->operator()(to, true /* dtorOnly */);
920 *engagementPtr = false;
921 } else {
922 if (!(*engagementPtr) && !(fSubfields[0]->GetTraits() & kTraitTriviallyConstructible))
923 CallConstructValueOn(*fSubfields[0], to);
924 CallReadOn(*fSubfields[0], itemIndex, to);
925 *engagementPtr = true;
926 }
927}
928
930{
931 *GetEngagementPtr(where) = false;
932}
933
935{
936 if (fItemDeleter) {
937 auto engagementPtr = reinterpret_cast<bool *>(reinterpret_cast<unsigned char *>(objPtr) + fEngagementPtrOffset);
938 if (*engagementPtr)
939 fItemDeleter->operator()(objPtr, true /* dtorOnly */);
940 }
941 RDeleter::operator()(objPtr, dtorOnly);
942}
943
944std::unique_ptr<ROOT::RFieldBase::RDeleter> ROOT::ROptionalField::GetDeleter() const
945{
946 return std::make_unique<ROptionalDeleter>(
947 (fSubfields[0]->GetTraits() & kTraitTriviallyDestructible) ? nullptr : GetDeleterOf(*fSubfields[0]),
948 fSubfields[0]->GetValueSize());
949}
950
951std::vector<ROOT::RFieldBase::RValue> ROOT::ROptionalField::SplitValue(const RValue &value) const
952{
953 std::vector<RValue> result;
954 const auto valuePtr = value.GetPtr<void>().get();
955 if (*GetEngagementPtr(valuePtr)) {
956 result.emplace_back(fSubfields[0]->BindValue(std::shared_ptr<void>(value.GetPtr<void>(), valuePtr)));
957 }
958 return result;
959}
960
962{
963 const auto alignment = GetAlignment();
964 // real size is the sum of the value size and the engagement boolean
965 const auto actualSize = fSubfields[0]->GetValueSize() + sizeof(bool);
966 auto padding = 0;
967 if (alignment > 1) {
968 auto remainder = actualSize % alignment;
969 if (remainder != 0)
970 padding = alignment - remainder;
971 }
972 return actualSize + padding;
973}
974
976{
977 return fSubfields[0]->GetAlignment();
978}
979
980//------------------------------------------------------------------------------
981
982ROOT::RAtomicField::RAtomicField(std::string_view fieldName, std::string_view typeName,
983 std::unique_ptr<RFieldBase> itemField)
984 : RFieldBase(fieldName, typeName, ROOT::ENTupleStructure::kPlain, false /* isSimple */)
985{
986 if (itemField->GetTraits() & kTraitTriviallyConstructible)
988 if (itemField->GetTraits() & kTraitTriviallyDestructible)
990 Attach(std::move(itemField));
991}
992
993std::unique_ptr<ROOT::RFieldBase> ROOT::RAtomicField::CloneImpl(std::string_view newName) const
994{
995 auto newItemField = fSubfields[0]->Clone(fSubfields[0]->GetFieldName());
996 return std::make_unique<RAtomicField>(newName, GetTypeName(), std::move(newItemField));
997}
998
999std::vector<ROOT::RFieldBase::RValue> ROOT::RAtomicField::SplitValue(const RValue &value) const
1000{
1001 std::vector<RValue> result;
1002 result.emplace_back(fSubfields[0]->BindValue(value.GetPtr<void>()));
1003 return result;
1004}
1005
1007{
1008 visitor.VisitAtomicField(*this);
1009}
dim_t fSize
static void BitsetReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to, size_t nBits, ROOT::Internal::RColumn &column)
Definition RField.cxx:697
static void BitsetReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to, size_t nBits, ROOT::Internal::RColumn &column)
Definition RField.cxx:718
static void BitsetAppendImpl(const void *from, size_t nBits, ROOT::Internal::RColumn &column)
Definition RField.cxx:674
#define f(i)
Definition RSha256.hxx:104
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:125
#define N
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 char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t result
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 value
char name[80]
Definition TGX11.cxx:110
TCanvas * alignment()
Definition alignment.C:1
Abstract base class for classes implementing the visitor design pattern.
The in-memory representation of a 32bit or 64bit on-disk index column.
A column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into ...
Definition RColumn.hxx:38
void Read(const ROOT::NTupleSize_t globalIndex, void *to)
Definition RColumn.hxx:160
void Append(const void *from)
Definition RColumn.hxx:126
RAtomicField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:982
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:1006
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:993
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given an existing value for this field.
Definition RField.cxx:999
RBitsetField(std::string_view fieldName, std::size_t N)
Definition RField.cxx:636
void ReadInClusterImpl(RNTupleLocalIndex localIndex, void *to) final
Definition RField.cxx:733
void GenerateColumns() final
Implementations in derived classes should create the backing columns corresponding to the field type ...
Definition RField.cxx:650
void ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:711
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:689
const RColumnRepresentations & GetColumnRepresentations() const final
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RField.cxx:644
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:738
void SelectWordSize(FUlong &&fUlong, FUlonglong &&fUlonglong, Args &&...args)
Definition RField.cxx:661
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:62
const RColumnRepresentations & GetColumnRepresentations() const final
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RField.cxx:47
const RField< RNTupleCardinality< std::uint32_t > > * As32Bit() const
Definition RField.cxx:67
const RField< RNTupleCardinality< std::uint64_t > > * As64Bit() const
Definition RField.cxx:72
void GenerateColumns() final
Implementations in derived classes should create the backing columns corresponding to the field type ...
Definition RField.hxx:335
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
void ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to) final
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
The list of column representations a field can have.
Points to an object with RNTuple I/O support and keeps a pointer to the corresponding field.
A field translates read and write calls from/to underlying columns to/from tree values.
void Attach(std::unique_ptr< RFieldBase > child)
Add a new subfield to the list of nested fields.
std::vector< std::unique_ptr< RFieldBase > > fSubfields
Collections and classes own subfields.
virtual const RColumnRepresentations & GetColumnRepresentations() const
Implementations in derived classes should return a static RColumnRepresentations object.
virtual void GenerateColumns()
Implementations in derived classes should create the backing columns corresponding to the field type ...
std::uint32_t fTraits
Properties of the type that allow for optimizations of collections of that type.
std::uint32_t GetTraits() const
@ kTraitEmulatedField
This field is a user defined type that was missing dictionaries and was reconstructed from the on-dis...
@ kTraitTrivialType
Shorthand for types that are both trivially constructible and destructible.
@ kTraitTriviallyDestructible
The type is cleaned up just by freeing its memory. I.e. the destructor performs a no-op.
@ kTraitTriviallyConstructible
No constructor needs to be called, i.e.
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:40
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:32
Classes with dictionaries that can be inspected by TClass.
Definition RField.hxx:287
The on-storage metadata of an RNTuple.
Addresses a column element or field item relative to a particular cluster, instead of a global NTuple...
Template specializations for C++ std::optional and std::unique_ptr.
std::size_t AppendNull()
Definition RField.cxx:772
RNTupleLocalIndex GetItemIndex(ROOT::NTupleSize_t globalIndex)
Given the index of the nullable field, returns the corresponding global index of the subfield or,...
Definition RField.cxx:786
RNullableField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:745
std::size_t AppendValue(const void *from)
Definition RField.cxx:778
void GenerateColumns() final
Implementations in derived classes should create the backing columns corresponding to the field type ...
Definition RField.cxx:762
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:794
const RFieldBase::RColumnRepresentations & GetColumnRepresentations() const final
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RField.cxx:752
void operator()(void *objPtr, bool dtorOnly) final
Definition RField.cxx:934
void ConstructValue(void *where) const final
Constructs value in a given location of size at least GetValueSize(). Called by the base class' Creat...
Definition RField.cxx:929
size_t GetAlignment() const final
As a rule of thumb, the alignment is equal to the size of the type.
Definition RField.cxx:975
std::unique_ptr< RDeleter > GetDeleter() const final
Definition RField.cxx:944
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:898
const bool * GetEngagementPtr(const void *optionalPtr) const
Given a pointer to an std::optional<T> in optionalPtr, extract a pointer to the engagement boolean.
Definition RField.cxx:893
void ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:913
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:904
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given an existing value for this field.
Definition RField.cxx:951
ROptionalField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:880
size_t GetValueSize() const final
The number of bytes taken by a value of the appropriate type.
Definition RField.cxx:961
void operator()(void *objPtr, bool dtorOnly) final
Definition RField.cxx:599
The field for an untyped record.
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given an existing value for this field.
Definition RField.cxx:617
std::size_t fMaxAlignment
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:564
void ReadInClusterImpl(RNTupleLocalIndex localIndex, void *to) final
Definition RField.cxx:585
RRecordField(std::string_view name, const RRecordField &source)
Definition RField.cxx:482
void AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:629
std::unique_ptr< RDeleter > GetDeleter() const final
Definition RField.cxx:607
void AttachItemFields(std::vector< std::unique_ptr< RFieldBase > > itemFields)
Definition RField.cxx:498
std::size_t GetItemPadding(std::size_t baseOffset, std::size_t itemAlignment) const
Definition RField.cxx:554
void ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:578
void ConstructValue(void *where) const final
Constructs value in a given location of size at least GetValueSize(). Called by the base class' Creat...
Definition RField.cxx:592
std::vector< std::size_t > fOffsets
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:569
void operator()(void *objPtr, bool dtorOnly) final
Definition RField.cxx:852
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given an existing value for this field.
Definition RField.cxx:867
RUniquePtrField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:801
std::unique_ptr< RDeleter > GetDeleter() const final
Definition RField.cxx:862
void ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:823
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:807
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:813
Template specializations for C++ std::vector.
std::unique_ptr< RFieldBase > CreateEmulatedVectorField(std::string_view fieldName, std::unique_ptr< RFieldBase > itemField, std::string_view emulatedFromType)
Definition RField.cxx:521
std::unique_ptr< RFieldBase > CreateEmulatedRecordField(std::string_view fieldName, std::vector< std::unique_ptr< RFieldBase > > itemFields, std::string_view emulatedFromType)
Definition RField.cxx:513
Namespace for new ROOT classes and functions.
constexpr NTupleSize_t kInvalidNTupleIndex
std::uint64_t NTupleSize_t
Integer type long enough to hold the maximum number of entries in a column.
ENTupleStructure
The fields in the RNTuple data model tree can carry different structural information about the type s...