doc/master/RField_8cxx_source.html

/// \file RField.cxx

/// \ingroup NTuple ROOT7

/// \author Jakob Blomer <jblomer@cern.ch>

/// \date 2018-10-15

/// \warning This is part of the ROOT 7 prototype! It will change without notice. It might trigger earthquakes. Feedback

/// is welcome!


/*************************************************************************

 * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *

 * All rights reserved.                                                  *

 *                                                                       *

 * For the licensing terms see $ROOTSYS/LICENSE.                         *

 * For the list of contributors see $ROOTSYS/README/CREDITS.             *

 *************************************************************************/


#include <ROOT/RColumn.hxx>

#include <ROOT/REntry.hxx>

#include <ROOT/RError.hxx>

#include <ROOT/RField.hxx>

#include <ROOT/RFieldVisitor.hxx>

#include <ROOT/RLogger.hxx>

#include <ROOT/RNTupleModel.hxx>

#include <ROOT/RNTupleSerialize.hxx>

#include <ROOT/RNTupleUtil.hxx>


#include <algorithm>

#include <cstdint>

#include <exception>

#include <functional>

#include <iostream>

#include <memory>

#include <type_traits>


std::unique_ptr<ROOT::Experimental::RFieldBase>

ROOT::Experimental::RFieldZero::CloneImpl(std::string_view /*newName*/) const

{

   auto result = std::make_unique<RFieldZero>();

   for (auto &f : fSubFields)

      result->Attach(f->Clone(f->GetFieldName()));

   return result;

}


void ROOT::Experimental::RFieldZero::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitFieldZero(*this);

}


//------------------------------------------------------------------------------


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RCardinalityField::GetColumnRepresentations() const

{

   static RColumnRepresentations representations(

      {{EColumnType::kSplitIndex64}, {EColumnType::kIndex64}, {EColumnType::kSplitIndex32}, {EColumnType::kIndex32}},

      {});

   return representations;

}


void ROOT::Experimental::RCardinalityField::GenerateColumns(const RNTupleDescriptor &desc)

{

   GenerateColumnsImpl<ClusterSize_t>(desc);

}


void ROOT::Experimental::RCardinalityField::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitCardinalityField(*this);

}


const ROOT::Experimental::RField<ROOT::RNTupleCardinality<std::uint32_t>> *

ROOT::Experimental::RCardinalityField::As32Bit() const

{

   return dynamic_cast<const RField<RNTupleCardinality<std::uint32_t>> *>(this);

}


const ROOT::Experimental::RField<ROOT::RNTupleCardinality<std::uint64_t>> *

ROOT::Experimental::RCardinalityField::As64Bit() const

{

   return dynamic_cast<const RField<RNTupleCardinality<std::uint64_t>> *>(this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<char>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RField<char>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kChar}}, {{EColumnType::kInt8},

                                                                          {EColumnType::kUInt8},

                                                                          {EColumnType::kInt16},

                                                                          {EColumnType::kUInt16},

                                                                          {EColumnType::kInt32},

                                                                          {EColumnType::kUInt32},

                                                                          {EColumnType::kInt64},

                                                                          {EColumnType::kUInt64},

                                                                          {EColumnType::kSplitInt16},

                                                                          {EColumnType::kSplitUInt16},

                                                                          {EColumnType::kSplitInt32},

                                                                          {EColumnType::kSplitUInt32},

                                                                          {EColumnType::kSplitInt64},

                                                                          {EColumnType::kSplitUInt64},

                                                                          {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RField<char>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitCharField(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<std::byte>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RField<std::byte>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kByte}}, {});

   return representations;

}


void ROOT::Experimental::RField<std::byte>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitByteField(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<int8_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::int8_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kInt8}}, {{EColumnType::kChar},

                                                                          {EColumnType::kUInt8},

                                                                          {EColumnType::kInt16},

                                                                          {EColumnType::kUInt16},

                                                                          {EColumnType::kInt32},

                                                                          {EColumnType::kUInt32},

                                                                          {EColumnType::kInt64},

                                                                          {EColumnType::kUInt64},

                                                                          {EColumnType::kSplitInt16},

                                                                          {EColumnType::kSplitUInt16},

                                                                          {EColumnType::kSplitInt32},

                                                                          {EColumnType::kSplitUInt32},

                                                                          {EColumnType::kSplitInt64},

                                                                          {EColumnType::kSplitUInt64},

                                                                          {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::int8_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitInt8Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<uint8_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::uint8_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kUInt8}}, {{EColumnType::kChar},

                                                                           {EColumnType::kInt8},

                                                                           {EColumnType::kInt16},

                                                                           {EColumnType::kUInt16},

                                                                           {EColumnType::kInt32},

                                                                           {EColumnType::kUInt32},

                                                                           {EColumnType::kInt64},

                                                                           {EColumnType::kUInt64},

                                                                           {EColumnType::kSplitInt16},

                                                                           {EColumnType::kSplitUInt16},

                                                                           {EColumnType::kSplitInt32},

                                                                           {EColumnType::kSplitUInt32},

                                                                           {EColumnType::kSplitInt64},

                                                                           {EColumnType::kSplitUInt64},

                                                                           {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::uint8_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitUInt8Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<bool>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RField<bool>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kBit}}, {{EColumnType::kChar},

                                                                         {EColumnType::kInt8},

                                                                         {EColumnType::kUInt8},

                                                                         {EColumnType::kInt16},

                                                                         {EColumnType::kUInt16},

                                                                         {EColumnType::kInt32},

                                                                         {EColumnType::kUInt32},

                                                                         {EColumnType::kInt64},

                                                                         {EColumnType::kUInt64},

                                                                         {EColumnType::kSplitInt16},

                                                                         {EColumnType::kSplitUInt16},

                                                                         {EColumnType::kSplitInt32},

                                                                         {EColumnType::kSplitUInt32},

                                                                         {EColumnType::kSplitInt64},

                                                                         {EColumnType::kSplitUInt64}});

   return representations;

}


void ROOT::Experimental::RField<bool>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitBoolField(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<float>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RField<float>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitReal32},

                                                  {EColumnType::kReal32},

                                                  {EColumnType::kReal16},

                                                  {EColumnType::kReal32Trunc},

                                                  {EColumnType::kReal32Quant}},

                                                 {{EColumnType::kSplitReal64}, {EColumnType::kReal64}});

   return representations;

}


void ROOT::Experimental::RField<float>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitFloatField(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<double>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RField<double>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitReal64},

                                                  {EColumnType::kReal64},

                                                  {EColumnType::kSplitReal32},

                                                  {EColumnType::kReal32},

                                                  {EColumnType::kReal16},

                                                  {EColumnType::kReal32Trunc},

                                                  {EColumnType::kReal32Quant}},

                                                 {});

   return representations;

}


void ROOT::Experimental::RField<double>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitDoubleField(*this);

}


void ROOT::Experimental::RField<double>::SetDouble32()

{

   fTypeAlias = "Double32_t";

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<int16_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::int16_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitInt16}, {EColumnType::kInt16}},

                                                 {{EColumnType::kChar},

                                                  {EColumnType::kInt8},

                                                  {EColumnType::kUInt8},

                                                  {EColumnType::kUInt16},

                                                  {EColumnType::kInt32},

                                                  {EColumnType::kUInt32},

                                                  {EColumnType::kInt64},

                                                  {EColumnType::kUInt64},

                                                  {EColumnType::kSplitUInt16},

                                                  {EColumnType::kSplitInt32},

                                                  {EColumnType::kSplitUInt32},

                                                  {EColumnType::kSplitInt64},

                                                  {EColumnType::kSplitUInt64},

                                                  {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::int16_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitInt16Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<uint16_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::uint16_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitUInt16}, {EColumnType::kUInt16}},

                                                 {{EColumnType::kChar},

                                                  {EColumnType::kInt8},

                                                  {EColumnType::kUInt8},

                                                  {EColumnType::kInt16},

                                                  {EColumnType::kInt32},

                                                  {EColumnType::kUInt32},

                                                  {EColumnType::kInt64},

                                                  {EColumnType::kUInt64},

                                                  {EColumnType::kSplitInt16},

                                                  {EColumnType::kSplitInt32},

                                                  {EColumnType::kSplitUInt32},

                                                  {EColumnType::kSplitInt64},

                                                  {EColumnType::kSplitUInt64},

                                                  {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::uint16_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitUInt16Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<int32_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::int32_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitInt32}, {EColumnType::kInt32}},

                                                 {{EColumnType::kChar},

                                                  {EColumnType::kInt8},

                                                  {EColumnType::kUInt8},

                                                  {EColumnType::kInt16},

                                                  {EColumnType::kUInt16},

                                                  {EColumnType::kUInt32},

                                                  {EColumnType::kInt64},

                                                  {EColumnType::kUInt64},

                                                  {EColumnType::kSplitInt16},

                                                  {EColumnType::kSplitUInt16},

                                                  {EColumnType::kSplitUInt32},

                                                  {EColumnType::kSplitInt64},

                                                  {EColumnType::kSplitUInt64},

                                                  {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::int32_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitInt32Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<uint32_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::uint32_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitUInt32}, {EColumnType::kUInt32}},

                                                 {{EColumnType::kChar},

                                                  {EColumnType::kInt8},

                                                  {EColumnType::kUInt8},

                                                  {EColumnType::kInt16},

                                                  {EColumnType::kUInt16},

                                                  {EColumnType::kInt32},

                                                  {EColumnType::kInt64},

                                                  {EColumnType::kUInt64},

                                                  {EColumnType::kSplitInt16},

                                                  {EColumnType::kSplitUInt16},

                                                  {EColumnType::kSplitInt32},

                                                  {EColumnType::kSplitInt64},

                                                  {EColumnType::kSplitUInt64},

                                                  {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::uint32_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitUInt32Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<uint64_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::uint64_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitUInt64}, {EColumnType::kUInt64}},

                                                 {{EColumnType::kChar},

                                                  {EColumnType::kInt8},

                                                  {EColumnType::kUInt8},

                                                  {EColumnType::kInt16},

                                                  {EColumnType::kUInt16},

                                                  {EColumnType::kInt32},

                                                  {EColumnType::kUInt32},

                                                  {EColumnType::kInt64},

                                                  {EColumnType::kSplitInt16},

                                                  {EColumnType::kSplitUInt16},

                                                  {EColumnType::kSplitInt32},

                                                  {EColumnType::kSplitUInt32},

                                                  {EColumnType::kSplitInt64},

                                                  {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::uint64_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitUInt64Field(*this);

}


//------------------------------------------------------------------------------


template class ROOT::Experimental::RSimpleField<int64_t>;


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RIntegralField<std::int64_t>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitInt64}, {EColumnType::kInt64}},

                                                 {{EColumnType::kChar},

                                                  {EColumnType::kInt8},

                                                  {EColumnType::kUInt8},

                                                  {EColumnType::kInt16},

                                                  {EColumnType::kUInt16},

                                                  {EColumnType::kInt32},

                                                  {EColumnType::kUInt32},

                                                  {EColumnType::kUInt64},

                                                  {EColumnType::kSplitInt16},

                                                  {EColumnType::kSplitUInt16},

                                                  {EColumnType::kSplitInt32},

                                                  {EColumnType::kSplitUInt32},

                                                  {EColumnType::kSplitUInt64},

                                                  {EColumnType::kBit}});

   return representations;

}


void ROOT::Experimental::RIntegralField<std::int64_t>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitInt64Field(*this);

}


//------------------------------------------------------------------------------


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RField<std::string>::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kSplitIndex64, EColumnType::kChar},

                                                  {EColumnType::kIndex64, EColumnType::kChar},

                                                  {EColumnType::kSplitIndex32, EColumnType::kChar},

                                                  {EColumnType::kIndex32, EColumnType::kChar}},

                                                 {});

   return representations;

}


void ROOT::Experimental::RField<std::string>::GenerateColumns()

{

   GenerateColumnsImpl<ClusterSize_t, char>();

}


void ROOT::Experimental::RField<std::string>::GenerateColumns(const RNTupleDescriptor &desc)

{

   GenerateColumnsImpl<ClusterSize_t, char>(desc);

}


std::size_t ROOT::Experimental::RField<std::string>::AppendImpl(const void *from)

{

   auto typedValue = static_cast<const std::string *>(from);

   auto length = typedValue->length();

   fAuxiliaryColumn->AppendV(typedValue->data(), length);

   fIndex += length;

   fPrincipalColumn->Append(&fIndex);

   return length + fPrincipalColumn->GetElement()->GetPackedSize();

}


void ROOT::Experimental::RField<std::string>::ReadGlobalImpl(ROOT::Experimental::NTupleSize_t globalIndex, void *to)

{

   auto typedValue = static_cast<std::string *>(to);

   RClusterIndex collectionStart;

   ClusterSize_t nChars;

   fPrincipalColumn->GetCollectionInfo(globalIndex, &collectionStart, &nChars);

   if (nChars == 0) {

      typedValue->clear();

   } else {

      typedValue->resize(nChars);

      fAuxiliaryColumn->ReadV(collectionStart, nChars, const_cast<char *>(typedValue->data()));

   }

}


void ROOT::Experimental::RField<std::string>::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitStringField(*this);

}


//------------------------------------------------------------------------------


ROOT::Experimental::RRecordField::RRecordField(std::string_view name, const RRecordField &source)

   : ROOT::Experimental::RFieldBase(name, source.GetTypeName(), ENTupleStructure::kRecord, false /* isSimple */),

     fMaxAlignment(source.fMaxAlignment),

     fSize(source.fSize),

     fOffsets(source.fOffsets)

{

   for (const auto &f : source.GetSubFields())

      Attach(f->Clone(f->GetFieldName()));

   fTraits = source.fTraits;

}


ROOT::Experimental::RRecordField::RRecordField(std::string_view fieldName, std::string_view typeName)

   : ROOT::Experimental::RFieldBase(fieldName, typeName, ENTupleStructure::kRecord, false /* isSimple */)

{

}


void ROOT::Experimental::RRecordField::RRecordField::AttachItemFields(

   std::vector<std::unique_ptr<RFieldBase>> itemFields)

{

   fTraits |= kTraitTrivialType;

   for (auto &item : itemFields) {

      fMaxAlignment = std::max(fMaxAlignment, item->GetAlignment());

      fSize += GetItemPadding(fSize, item->GetAlignment()) + item->GetValueSize();

      fTraits &= item->GetTraits();

      Attach(std::move(item));

   }

   // Trailing padding: although this is implementation-dependent, most add enough padding to comply with the

   // requirements of the type with strictest alignment

   fSize += GetItemPadding(fSize, fMaxAlignment);

}


ROOT::Experimental::RRecordField::RRecordField(std::string_view fieldName,

                                               std::vector<std::unique_ptr<RFieldBase>> itemFields)

   : ROOT::Experimental::RFieldBase(fieldName, "", ENTupleStructure::kRecord, false /* isSimple */)

{

   fTraits |= kTraitTrivialType;

   fOffsets.reserve(itemFields.size());

   for (auto &item : itemFields) {

      fSize += GetItemPadding(fSize, item->GetAlignment());

      fOffsets.push_back(fSize);

      fMaxAlignment = std::max(fMaxAlignment, item->GetAlignment());

      fSize += item->GetValueSize();

      fTraits &= item->GetTraits();

      Attach(std::move(item));

   }

   // Trailing padding: although this is implementation-dependent, most add enough padding to comply with the

   // requirements of the type with strictest alignment

   fSize += GetItemPadding(fSize, fMaxAlignment);

}


std::size_t ROOT::Experimental::RRecordField::GetItemPadding(std::size_t baseOffset, std::size_t itemAlignment) const

{

   if (itemAlignment > 1) {

      auto remainder = baseOffset % itemAlignment;

      if (remainder != 0)

         return itemAlignment - remainder;

   }

   return 0;

}


std::unique_ptr<ROOT::Experimental::RFieldBase>

ROOT::Experimental::RRecordField::CloneImpl(std::string_view newName) const

{

   return std::unique_ptr<RRecordField>(new RRecordField(newName, *this));

}


std::size_t ROOT::Experimental::RRecordField::AppendImpl(const void *from)

{

   std::size_t nbytes = 0;

   for (unsigned i = 0; i < fSubFields.size(); ++i) {

      nbytes += CallAppendOn(*fSubFields[i], static_cast<const unsigned char *>(from) + fOffsets[i]);

   }

   return nbytes;

}


void ROOT::Experimental::RRecordField::ReadGlobalImpl(NTupleSize_t globalIndex, void *to)

{

   for (unsigned i = 0; i < fSubFields.size(); ++i) {

      CallReadOn(*fSubFields[i], globalIndex, static_cast<unsigned char *>(to) + fOffsets[i]);

   }

}


void ROOT::Experimental::RRecordField::ReadInClusterImpl(RClusterIndex clusterIndex, void *to)

{

   for (unsigned i = 0; i < fSubFields.size(); ++i) {

      CallReadOn(*fSubFields[i], clusterIndex, static_cast<unsigned char *>(to) + fOffsets[i]);

   }

}


void ROOT::Experimental::RRecordField::ConstructValue(void *where) const

{

   for (unsigned i = 0; i < fSubFields.size(); ++i) {

      CallConstructValueOn(*fSubFields[i], static_cast<unsigned char *>(where) + fOffsets[i]);

   }

}


void ROOT::Experimental::RRecordField::RRecordDeleter::operator()(void *objPtr, bool dtorOnly)

{

   for (unsigned i = 0; i < fItemDeleters.size(); ++i) {

      fItemDeleters[i]->operator()(reinterpret_cast<unsigned char *>(objPtr) + fOffsets[i], true /* dtorOnly */);

   }

   RDeleter::operator()(objPtr, dtorOnly);

}


std::unique_ptr<ROOT::Experimental::RFieldBase::RDeleter> ROOT::Experimental::RRecordField::GetDeleter() const

{

   std::vector<std::unique_ptr<RDeleter>> itemDeleters;

   itemDeleters.reserve(fOffsets.size());

   for (const auto &f : fSubFields) {

      itemDeleters.emplace_back(GetDeleterOf(*f));

   }

   return std::make_unique<RRecordDeleter>(std::move(itemDeleters), fOffsets);

}


std::vector<ROOT::Experimental::RFieldBase::RValue>

ROOT::Experimental::RRecordField::SplitValue(const RValue &value) const

{

   auto basePtr = value.GetPtr<unsigned char>().get();

   std::vector<RValue> result;

   result.reserve(fSubFields.size());

   for (unsigned i = 0; i < fSubFields.size(); ++i) {

      result.emplace_back(fSubFields[i]->BindValue(std::shared_ptr<void>(value.GetPtr<void>(), basePtr + fOffsets[i])));

   }

   return result;

}


void ROOT::Experimental::RRecordField::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitRecordField(*this);

}


//------------------------------------------------------------------------------


ROOT::Experimental::RBitsetField::RBitsetField(std::string_view fieldName, std::size_t N)

   : ROOT::Experimental::RFieldBase(fieldName, "std::bitset<" + std::to_string(N) + ">", ENTupleStructure::kLeaf,

                                    false /* isSimple */, N),

     fN(N)

{

   fTraits |= kTraitTriviallyDestructible;

}


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RBitsetField::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{EColumnType::kBit}}, {});

   return representations;

}


void ROOT::Experimental::RBitsetField::GenerateColumns()

{

   GenerateColumnsImpl<bool>();

}


void ROOT::Experimental::RBitsetField::GenerateColumns(const RNTupleDescriptor &desc)

{

   GenerateColumnsImpl<bool>(desc);

}


std::size_t ROOT::Experimental::RBitsetField::AppendImpl(const void *from)

{

   const auto *asULongArray = static_cast<const Word_t *>(from);

   bool elementValue;

   std::size_t i = 0;

   for (std::size_t word = 0; word < (fN + kBitsPerWord - 1) / kBitsPerWord; ++word) {

      for (std::size_t mask = 0; (mask < kBitsPerWord) && (i < fN); ++mask, ++i) {

         elementValue = (asULongArray[word] & (static_cast<Word_t>(1) << mask)) != 0;

         fPrincipalColumn->Append(&elementValue);

      }

   }

   return fN;

}


void ROOT::Experimental::RBitsetField::ReadGlobalImpl(NTupleSize_t globalIndex, void *to)

{

   auto *asULongArray = static_cast<Word_t *>(to);

   bool elementValue;

   for (std::size_t i = 0; i < fN; ++i) {

      fPrincipalColumn->Read(globalIndex * fN + i, &elementValue);

      Word_t mask = static_cast<Word_t>(1) << (i % kBitsPerWord);

      Word_t bit = static_cast<Word_t>(elementValue) << (i % kBitsPerWord);

      asULongArray[i / kBitsPerWord] = (asULongArray[i / kBitsPerWord] & ~mask) | bit;

   }

}


void ROOT::Experimental::RBitsetField::ReadInClusterImpl(RClusterIndex clusterIndex, void *to)

{

   auto *asULongArray = static_cast<Word_t *>(to);

   bool elementValue;

   for (std::size_t i = 0; i < fN; ++i) {

      fPrincipalColumn->Read(RClusterIndex(clusterIndex.GetClusterId(), clusterIndex.GetIndex() * fN) + i,

                             &elementValue);

      Word_t mask = static_cast<Word_t>(1) << (i % kBitsPerWord);

      Word_t bit = static_cast<Word_t>(elementValue) << (i % kBitsPerWord);

      asULongArray[i / kBitsPerWord] = (asULongArray[i / kBitsPerWord] & ~mask) | bit;

   }

}


void ROOT::Experimental::RBitsetField::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitBitsetField(*this);

}


//------------------------------------------------------------------------------


ROOT::Experimental::RNullableField::RNullableField(std::string_view fieldName, std::string_view typeName,

                                                   std::unique_ptr<RFieldBase> itemField)

   : ROOT::Experimental::RFieldBase(fieldName, typeName, ENTupleStructure::kCollection, false /* isSimple */)

{

   Attach(std::move(itemField));

}


const ROOT::Experimental::RFieldBase::RColumnRepresentations &

ROOT::Experimental::RNullableField::GetColumnRepresentations() const

{

   static RColumnRepresentations representations(

      {{EColumnType::kSplitIndex64}, {EColumnType::kIndex64}, {EColumnType::kSplitIndex32}, {EColumnType::kIndex32}},

      {});

   return representations;

}


void ROOT::Experimental::RNullableField::GenerateColumns()

{

   GenerateColumnsImpl<ClusterSize_t>();

}


void ROOT::Experimental::RNullableField::GenerateColumns(const RNTupleDescriptor &desc)

{

   GenerateColumnsImpl<ClusterSize_t>(desc);

}


std::size_t ROOT::Experimental::RNullableField::AppendNull()

{

   fPrincipalColumn->Append(&fNWritten);

   return sizeof(ClusterSize_t);

}


std::size_t ROOT::Experimental::RNullableField::AppendValue(const void *from)

{

   auto nbytesItem = CallAppendOn(*fSubFields[0], from);

   fNWritten++;

   fPrincipalColumn->Append(&fNWritten);

   return sizeof(ClusterSize_t) + nbytesItem;

}


ROOT::Experimental::RClusterIndex ROOT::Experimental::RNullableField::GetItemIndex(NTupleSize_t globalIndex)

{

   RClusterIndex collectionStart;

   ClusterSize_t collectionSize;

   fPrincipalColumn->GetCollectionInfo(globalIndex, &collectionStart, &collectionSize);

   return (collectionSize == 0) ? RClusterIndex() : collectionStart;

}


void ROOT::Experimental::RNullableField::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitNullableField(*this);

}


//------------------------------------------------------------------------------


ROOT::Experimental::RUniquePtrField::RUniquePtrField(std::string_view fieldName, std::string_view typeName,

                                                     std::unique_ptr<RFieldBase> itemField)

   : RNullableField(fieldName, typeName, std::move(itemField)), fItemDeleter(GetDeleterOf(*fSubFields[0]))

{

}


std::unique_ptr<ROOT::Experimental::RFieldBase>

ROOT::Experimental::RUniquePtrField::CloneImpl(std::string_view newName) const

{

   auto newItemField = fSubFields[0]->Clone(fSubFields[0]->GetFieldName());

   return std::make_unique<RUniquePtrField>(newName, GetTypeName(), std::move(newItemField));

}


std::size_t ROOT::Experimental::RUniquePtrField::AppendImpl(const void *from)

{

   auto typedValue = static_cast<const std::unique_ptr<char> *>(from);

   if (*typedValue) {

      return AppendValue(typedValue->get());

   } else {

      return AppendNull();

   }

}


void ROOT::Experimental::RUniquePtrField::ReadGlobalImpl(NTupleSize_t globalIndex, void *to)

{

   auto ptr = static_cast<std::unique_ptr<char> *>(to);

   bool isValidValue = static_cast<bool>(*ptr);


   auto itemIndex = GetItemIndex(globalIndex);

   bool isValidItem = itemIndex.GetIndex() != kInvalidClusterIndex;


   void *valuePtr = nullptr;

   if (isValidValue)

      valuePtr = ptr->get();


   if (isValidValue && !isValidItem) {

      ptr->release();

      fItemDeleter->operator()(valuePtr, false /* dtorOnly */);

      return;

   }


   if (!isValidItem) // On-disk value missing; nothing else to do

      return;


   if (!isValidValue) {

      valuePtr = CallCreateObjectRawPtrOn(*fSubFields[0]);

      ptr->reset(reinterpret_cast<char *>(valuePtr));

   }


   CallReadOn(*fSubFields[0], itemIndex, valuePtr);

}


void ROOT::Experimental::RUniquePtrField::RUniquePtrDeleter::operator()(void *objPtr, bool dtorOnly)

{

   auto typedPtr = static_cast<std::unique_ptr<char> *>(objPtr);

   if (*typedPtr) {

      fItemDeleter->operator()(typedPtr->get(), false /* dtorOnly */);

      typedPtr->release();

   }

   RDeleter::operator()(objPtr, dtorOnly);

}


std::unique_ptr<ROOT::Experimental::RFieldBase::RDeleter> ROOT::Experimental::RUniquePtrField::GetDeleter() const

{

   return std::make_unique<RUniquePtrDeleter>(GetDeleterOf(*fSubFields[0]));

}


std::vector<ROOT::Experimental::RFieldBase::RValue>

ROOT::Experimental::RUniquePtrField::SplitValue(const RValue &value) const

{

   std::vector<RValue> result;

   const auto &ptr = value.GetRef<std::unique_ptr<char>>();

   if (ptr) {

      result.emplace_back(fSubFields[0]->BindValue(std::shared_ptr<void>(value.GetPtr<void>(), ptr.get())));

   }

   return result;

}


//------------------------------------------------------------------------------


ROOT::Experimental::ROptionalField::ROptionalField(std::string_view fieldName, std::string_view typeName,

                                                   std::unique_ptr<RFieldBase> itemField)

   : RNullableField(fieldName, typeName, std::move(itemField)), fItemDeleter(GetDeleterOf(*fSubFields[0]))

{

   if (fSubFields[0]->GetTraits() & kTraitTriviallyDestructible)

      fTraits |= kTraitTriviallyDestructible;

}


bool *ROOT::Experimental::ROptionalField::GetEngagementPtr(void *optionalPtr) const

{

   return reinterpret_cast<bool *>(reinterpret_cast<unsigned char *>(optionalPtr) + fSubFields[0]->GetValueSize());

}


const bool *ROOT::Experimental::ROptionalField::GetEngagementPtr(const void *optionalPtr) const

{

   return GetEngagementPtr(const_cast<void *>(optionalPtr));

}


std::unique_ptr<ROOT::Experimental::RFieldBase>

ROOT::Experimental::ROptionalField::CloneImpl(std::string_view newName) const

{

   auto newItemField = fSubFields[0]->Clone(fSubFields[0]->GetFieldName());

   return std::make_unique<ROptionalField>(newName, GetTypeName(), std::move(newItemField));

}


std::size_t ROOT::Experimental::ROptionalField::AppendImpl(const void *from)

{

   if (*GetEngagementPtr(from)) {

      return AppendValue(from);

   } else {

      return AppendNull();

   }

}


void ROOT::Experimental::ROptionalField::ReadGlobalImpl(NTupleSize_t globalIndex, void *to)

{

   auto engagementPtr = GetEngagementPtr(to);

   auto itemIndex = GetItemIndex(globalIndex);

   if (itemIndex.GetIndex() == kInvalidClusterIndex) {

      if (*engagementPtr && !(fSubFields[0]->GetTraits() & kTraitTriviallyDestructible))

         fItemDeleter->operator()(to, true /* dtorOnly */);

      *engagementPtr = false;

   } else {

      if (!(*engagementPtr) && !(fSubFields[0]->GetTraits() & kTraitTriviallyConstructible))

         CallConstructValueOn(*fSubFields[0], to);

      CallReadOn(*fSubFields[0], itemIndex, to);

      *engagementPtr = true;

   }

}


void ROOT::Experimental::ROptionalField::ConstructValue(void *where) const

{

   *GetEngagementPtr(where) = false;

}


void ROOT::Experimental::ROptionalField::ROptionalDeleter::operator()(void *objPtr, bool dtorOnly)

{

   if (fItemDeleter) {

      auto engagementPtr = reinterpret_cast<bool *>(reinterpret_cast<unsigned char *>(objPtr) + fEngagementPtrOffset);

      if (*engagementPtr)

         fItemDeleter->operator()(objPtr, true /* dtorOnly */);

   }

   RDeleter::operator()(objPtr, dtorOnly);

}


std::unique_ptr<ROOT::Experimental::RFieldBase::RDeleter> ROOT::Experimental::ROptionalField::GetDeleter() const

{

   return std::make_unique<ROptionalDeleter>(

      (fSubFields[0]->GetTraits() & kTraitTriviallyDestructible) ? nullptr : GetDeleterOf(*fSubFields[0]),

      fSubFields[0]->GetValueSize());

}


std::vector<ROOT::Experimental::RFieldBase::RValue>

ROOT::Experimental::ROptionalField::SplitValue(const RValue &value) const

{

   std::vector<RValue> result;

   const auto valuePtr = value.GetPtr<void>().get();

   if (*GetEngagementPtr(valuePtr)) {

      result.emplace_back(fSubFields[0]->BindValue(std::shared_ptr<void>(value.GetPtr<void>(), valuePtr)));

   }

   return result;

}


size_t ROOT::Experimental::ROptionalField::GetValueSize() const

{

   const auto alignment = GetAlignment();

   // real size is the sum of the value size and the engagement boolean

   const auto actualSize = fSubFields[0]->GetValueSize() + sizeof(bool);

   auto padding = 0;

   if (alignment > 1) {

      auto remainder = actualSize % alignment;

      if (remainder != 0)

         padding = alignment - remainder;

   }

   return actualSize + padding;

}


size_t ROOT::Experimental::ROptionalField::GetAlignment() const

{

   return fSubFields[0]->GetAlignment();

}


//------------------------------------------------------------------------------


ROOT::Experimental::RAtomicField::RAtomicField(std::string_view fieldName, std::string_view typeName,

                                               std::unique_ptr<RFieldBase> itemField)

   : RFieldBase(fieldName, typeName, ENTupleStructure::kLeaf, false /* isSimple */)

{

   if (itemField->GetTraits() & kTraitTriviallyConstructible)

      fTraits |= kTraitTriviallyConstructible;

   if (itemField->GetTraits() & kTraitTriviallyDestructible)

      fTraits |= kTraitTriviallyDestructible;

   Attach(std::move(itemField));

}


std::unique_ptr<ROOT::Experimental::RFieldBase>

ROOT::Experimental::RAtomicField::CloneImpl(std::string_view newName) const

{

   auto newItemField = fSubFields[0]->Clone(fSubFields[0]->GetFieldName());

   return std::make_unique<RAtomicField>(newName, GetTypeName(), std::move(newItemField));

}


std::vector<ROOT::Experimental::RFieldBase::RValue>

ROOT::Experimental::RAtomicField::SplitValue(const RValue &value) const

{

   std::vector<RValue> result;

   result.emplace_back(fSubFields[0]->BindValue(value.GetPtr<void>()));

   return result;

}


void ROOT::Experimental::RAtomicField::AcceptVisitor(Detail::RFieldVisitor &visitor) const

{

   visitor.VisitAtomicField(*this);

}

fSize
dim_t fSize
Definition DeclareExecutors.h:183

RColumn.hxx

REntry.hxx

RError.hxx

RFieldVisitor.hxx

RField.hxx

RLogger.hxx

RNTupleModel.hxx

RNTupleSerialize.hxx

RNTupleUtil.hxx

f
#define f(i)
Definition RSha256.hxx:104

N
#define N

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 mask
Definition TGWin32VirtualXProxy.cxx:178

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 result
Definition TGWin32VirtualXProxy.cxx:174

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 length
Definition TGWin32VirtualXProxy.cxx:245

value
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void value
Definition TGWin32VirtualXProxy.cxx:142

name
char name[80]
Definition TGX11.cxx:110

alignment
TCanvas * alignment()
Definition alignment.C:1

ROOT::Experimental::Detail::RFieldVisitor
Abstract base class for classes implementing the visitor design pattern.
Definition RFieldVisitor.hxx:43

ROOT::Experimental::Detail::RFieldVisitor::VisitBoolField
virtual void VisitBoolField(const RField< bool > &field)
Definition RFieldVisitor.hxx:51

ROOT::Experimental::Detail::RFieldVisitor::VisitBitsetField
virtual void VisitBitsetField(const RBitsetField &field)
Definition RFieldVisitor.hxx:50

ROOT::Experimental::Detail::RFieldVisitor::VisitNullableField
virtual void VisitNullableField(const RNullableField &field)
Definition RFieldVisitor.hxx:69

ROOT::Experimental::Detail::RFieldVisitor::VisitFieldZero
virtual void VisitFieldZero(const RFieldZero &field)
Definition RFieldVisitor.hxx:46

ROOT::Experimental::Detail::RFieldVisitor::VisitCardinalityField
virtual void VisitCardinalityField(const RCardinalityField &field)
Definition RFieldVisitor.hxx:57

ROOT::Experimental::Detail::RFieldVisitor::VisitDoubleField
virtual void VisitDoubleField(const RField< double > &field)
Definition RFieldVisitor.hxx:58

ROOT::Experimental::Detail::RFieldVisitor::VisitCharField
virtual void VisitCharField(const RField< char > &field)
Definition RFieldVisitor.hxx:62

ROOT::Experimental::Detail::RFieldVisitor::VisitRecordField
virtual void VisitRecordField(const RRecordField &field)
Definition RFieldVisitor.hxx:56

ROOT::Experimental::Detail::RFieldVisitor::VisitFloatField
virtual void VisitFloatField(const RField< float > &field)
Definition RFieldVisitor.hxx:60

ROOT::Experimental::Detail::RFieldVisitor::VisitAtomicField
virtual void VisitAtomicField(const RAtomicField &field)
Definition RFieldVisitor.hxx:49

ROOT::Experimental::RAtomicField::CloneImpl
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:955

ROOT::Experimental::RAtomicField::RAtomicField
RAtomicField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:943

ROOT::Experimental::RAtomicField::SplitValue
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given a value for this field.
Definition RField.cxx:962

ROOT::Experimental::RAtomicField::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:969

ROOT::Experimental::RBitsetField::Word_t
unsigned long Word_t
Definition RFieldSTLMisc.hxx:89

ROOT::Experimental::RBitsetField::AppendImpl
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:658

ROOT::Experimental::RBitsetField::ReadGlobalImpl
void ReadGlobalImpl(NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:672

ROOT::Experimental::RBitsetField::RBitsetField
RBitsetField(std::string_view fieldName, std::size_t N)
Definition RField.cxx:633

ROOT::Experimental::RBitsetField::GenerateColumns
void GenerateColumns() final
Implementations in derived classes should create the backing columns corresponsing to the field type ...
Definition RField.cxx:648

ROOT::Experimental::RBitsetField::GetColumnRepresentations
const RColumnRepresentations & GetColumnRepresentations() const final
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RField.cxx:642

ROOT::Experimental::RBitsetField::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:697

ROOT::Experimental::RBitsetField::ReadInClusterImpl
void ReadInClusterImpl(RClusterIndex clusterIndex, void *to) final
Definition RField.cxx:684

ROOT::Experimental::RCardinalityField::GetColumnRepresentations
const RColumnRepresentations & GetColumnRepresentations() const final
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RField.cxx:51

ROOT::Experimental::RCardinalityField::GenerateColumns
void GenerateColumns() final
Implementations in derived classes should create the backing columns corresponsing to the field type ...
Definition RField.hxx:290

ROOT::Experimental::RCardinalityField::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:64

ROOT::Experimental::RCardinalityField::As32Bit
const RField< RNTupleCardinality< std::uint32_t > > * As32Bit() const
Definition RField.cxx:70

ROOT::Experimental::RCardinalityField::As64Bit
const RField< RNTupleCardinality< std::uint64_t > > * As64Bit() const
Definition RField.cxx:76

ROOT::Experimental::RClassField::AppendImpl
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RFieldMeta.cxx:178

ROOT::Experimental::RClassField::ReadGlobalImpl
void ReadGlobalImpl(NTupleSize_t globalIndex, void *to) final
Definition RFieldMeta.cxx:187

ROOT::Experimental::RClassField::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RFieldMeta.cxx:298

ROOT::Experimental::RClusterIndex
Addresses a column element or field item relative to a particular cluster, instead of a global NTuple...
Definition RNTupleUtil.hxx:172

ROOT::Experimental::RClusterIndex::GetClusterId
DescriptorId_t GetClusterId() const
Definition RNTupleUtil.hxx:202

ROOT::Experimental::RClusterIndex::GetIndex
ClusterSize_t::ValueType GetIndex() const
Definition RNTupleUtil.hxx:203

ROOT::Experimental::RFieldBase::RColumnRepresentations
Some fields have multiple possible column representations, e.g.
Definition RFieldBase.hxx:147

ROOT::Experimental::RFieldBase::RValue
Points to an object with RNTuple I/O support and keeps a pointer to the corresponding field.
Definition RFieldBase.hxx:655

ROOT::Experimental::RFieldBase
A field translates read and write calls from/to underlying columns to/from tree values.
Definition RFieldBase.hxx:70

ROOT::Experimental::RFieldBase::kTraitTriviallyDestructible
static constexpr int kTraitTriviallyDestructible
The type is cleaned up just by freeing its memory. I.e. the destructor performs a no-op.
Definition RFieldBase.hxx:121

ROOT::Experimental::RFieldBase::GenerateColumns
virtual void GenerateColumns()
Implementations in derived classes should create the backing columns corresponsing to the field type ...
Definition RFieldBase.hxx:340

ROOT::Experimental::RFieldBase::Attach
void Attach(std::unique_ptr< RFieldBase > child)
Add a new subfield to the list of nested fields.
Definition RFieldBase.cxx:657

ROOT::Experimental::RFieldBase::GetSubFields
std::vector< RFieldBase * > GetSubFields()
Definition RFieldBase.cxx:680

ROOT::Experimental::RFieldBase::kTraitTriviallyConstructible
static constexpr int kTraitTriviallyConstructible
No constructor needs to be called, i.e.
Definition RFieldBase.hxx:119

ROOT::Experimental::RFieldBase::GetTraits
int GetTraits() const
Definition RFieldBase.hxx:532

ROOT::Experimental::RFieldBase::fTraits
int fTraits
Properties of the type that allow for optimizations of collections of that type.
Definition RFieldBase.hxx:256

ROOT::Experimental::RFieldBase::Clone
std::unique_ptr< RFieldBase > Clone(std::string_view newName) const
Copies the field and its sub fields using a possibly new name and a new, unconnected set of columns.
Definition RFieldBase.cxx:590

ROOT::Experimental::RFieldBase::fSubFields
std::vector< std::unique_ptr< RFieldBase > > fSubFields
Collections and classes own sub fields.
Definition RFieldBase.hxx:239

ROOT::Experimental::RFieldBase::kTraitTrivialType
static constexpr int kTraitTrivialType
Shorthand for types that are both trivially constructible and destructible.
Definition RFieldBase.hxx:128

ROOT::Experimental::RFieldBase::GetColumnRepresentations
virtual const RColumnRepresentations & GetColumnRepresentations() const
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RFieldBase.cxx:584

ROOT::Experimental::RFieldZero::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:43

ROOT::Experimental::RFieldZero::CloneImpl
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:35

ROOT::Experimental::RField
Classes with dictionaries that can be inspected by TClass.
Definition RField.hxx:242

ROOT::Experimental::RIntegralField
Definition RFieldFundamental.hxx:109

ROOT::Experimental::RNTupleDescriptor
The on-storage meta-data of an ntuple.
Definition RNTupleDescriptor.hxx:535

ROOT::Experimental::RNullableField
Template specializations for C++ std::optional and std::unique_ptr.
Definition RFieldSTLMisc.hxx:167

ROOT::Experimental::RNullableField::GetColumnRepresentations
const RFieldBase::RColumnRepresentations & GetColumnRepresentations() const final
Implementations in derived classes should return a static RColumnRepresentations object.
Definition RField.cxx:712

ROOT::Experimental::RNullableField::GenerateColumns
void GenerateColumns() final
Implementations in derived classes should create the backing columns corresponsing to the field type ...
Definition RField.cxx:720

ROOT::Experimental::RNullableField::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:752

ROOT::Experimental::RNullableField::GetItemIndex
RClusterIndex GetItemIndex(NTupleSize_t globalIndex)
Given the index of the nullable field, returns the corresponding global index of the subfield or,...
Definition RField.cxx:744

ROOT::Experimental::RNullableField::RNullableField
RNullableField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:704

ROOT::Experimental::RNullableField::AppendNull
std::size_t AppendNull()
Definition RField.cxx:730

ROOT::Experimental::RNullableField::AppendValue
std::size_t AppendValue(const void *from)
Definition RField.cxx:736

ROOT::Experimental::ROptionalField::ROptionalDeleter::operator()
void operator()(void *objPtr, bool dtorOnly) final
Definition RField.cxx:894

ROOT::Experimental::ROptionalField::ReadGlobalImpl
void ReadGlobalImpl(NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:873

ROOT::Experimental::ROptionalField::ConstructValue
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:889

ROOT::Experimental::ROptionalField::GetDeleter
std::unique_ptr< RDeleter > GetDeleter() const final
Definition RField.cxx:904

ROOT::Experimental::ROptionalField::GetAlignment
size_t GetAlignment() const final
As a rule of thumb, the alignment is equal to the size of the type.
Definition RField.cxx:936

ROOT::Experimental::ROptionalField::AppendImpl
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:864

ROOT::Experimental::ROptionalField::GetEngagementPtr
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:852

ROOT::Experimental::ROptionalField::ROptionalField
ROptionalField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:839

ROOT::Experimental::ROptionalField::GetValueSize
size_t GetValueSize() const final
The number of bytes taken by a value of the appropriate type.
Definition RField.cxx:922

ROOT::Experimental::ROptionalField::CloneImpl
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:858

ROOT::Experimental::ROptionalField::SplitValue
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given a value for this field.
Definition RField.cxx:912

ROOT::Experimental::RRecordField::RRecordDeleter::operator()
void operator()(void *objPtr, bool dtorOnly) final
Definition RField.cxx:596

ROOT::Experimental::RRecordField
The field for an untyped record.
Definition RFieldRecord.hxx:41

ROOT::Experimental::RRecordField::fMaxAlignment
std::size_t fMaxAlignment
Definition RFieldRecord.hxx:59

ROOT::Experimental::RRecordField::fOffsets
std::vector< std::size_t > fOffsets
Definition RFieldRecord.hxx:61

ROOT::Experimental::RRecordField::CloneImpl
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:561

ROOT::Experimental::RRecordField::ReadInClusterImpl
void ReadInClusterImpl(RClusterIndex clusterIndex, void *to) final
Definition RField.cxx:582

ROOT::Experimental::RRecordField::RRecordField
RRecordField(std::string_view name, const RRecordField &source)
Definition RField.cxx:500

ROOT::Experimental::RRecordField::ReadGlobalImpl
void ReadGlobalImpl(NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:575

ROOT::Experimental::RRecordField::SplitValue
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given a value for this field.
Definition RField.cxx:615

ROOT::Experimental::RRecordField::GetItemPadding
std::size_t GetItemPadding(std::size_t baseOffset, std::size_t itemAlignment) const
Definition RField.cxx:550

ROOT::Experimental::RRecordField::GetDeleter
std::unique_ptr< RDeleter > GetDeleter() const final
Definition RField.cxx:604

ROOT::Experimental::RRecordField::AppendImpl
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:566

ROOT::Experimental::RRecordField::fSize
std::size_t fSize
Definition RFieldRecord.hxx:60

ROOT::Experimental::RRecordField::AcceptVisitor
void AcceptVisitor(Detail::RFieldVisitor &visitor) const final
Definition RField.cxx:626

ROOT::Experimental::RRecordField::ConstructValue
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:589

ROOT::Experimental::RSimpleField
Definition RField.hxx:305

ROOT::Experimental::RUniquePtrField::RUniquePtrDeleter::operator()
void operator()(void *objPtr, bool dtorOnly) final
Definition RField.cxx:811

ROOT::Experimental::RUniquePtrField::CloneImpl
std::unique_ptr< RFieldBase > CloneImpl(std::string_view newName) const final
Called by Clone(), which additionally copies the on-disk ID.
Definition RField.cxx:766

ROOT::Experimental::RUniquePtrField::ReadGlobalImpl
void ReadGlobalImpl(NTupleSize_t globalIndex, void *to) final
Definition RField.cxx:782

ROOT::Experimental::RUniquePtrField::SplitValue
std::vector< RValue > SplitValue(const RValue &value) const final
Creates the list of direct child values given a value for this field.
Definition RField.cxx:827

ROOT::Experimental::RUniquePtrField::RUniquePtrField
RUniquePtrField(std::string_view fieldName, std::string_view typeName, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:759

ROOT::Experimental::RUniquePtrField::GetDeleter
std::unique_ptr< RDeleter > GetDeleter() const final
Definition RField.cxx:821

ROOT::Experimental::RUniquePtrField::AppendImpl
std::size_t AppendImpl(const void *from) final
Operations on values of complex types, e.g.
Definition RField.cxx:772

bool

ROOT::Experimental::NTupleSize_t
std::uint64_t NTupleSize_t
Integer type long enough to hold the maximum number of entries in a column.
Definition RNTupleUtil.hxx:117

ROOT::Experimental::EColumnType::kUInt8
@ kUInt8

ROOT::Experimental::EColumnType::kByte
@ kByte

ROOT::Experimental::EColumnType::kInt32
@ kInt32

ROOT::Experimental::EColumnType::kSplitReal64
@ kSplitReal64

ROOT::Experimental::EColumnType::kInt64
@ kInt64

ROOT::Experimental::EColumnType::kBit
@ kBit

ROOT::Experimental::EColumnType::kReal64
@ kReal64

ROOT::Experimental::EColumnType::kSplitInt64
@ kSplitInt64

ROOT::Experimental::EColumnType::kReal32Quant
@ kReal32Quant

ROOT::Experimental::EColumnType::kReal16
@ kReal16

ROOT::Experimental::EColumnType::kUInt32
@ kUInt32

ROOT::Experimental::EColumnType::kInt16
@ kInt16

ROOT::Experimental::EColumnType::kSplitIndex64
@ kSplitIndex64

ROOT::Experimental::EColumnType::kSplitIndex32
@ kSplitIndex32

ROOT::Experimental::EColumnType::kIndex32
@ kIndex32

ROOT::Experimental::EColumnType::kIndex64
@ kIndex64

ROOT::Experimental::EColumnType::kSplitInt32
@ kSplitInt32

ROOT::Experimental::EColumnType::kUInt16
@ kUInt16

ROOT::Experimental::EColumnType::kSplitUInt16
@ kSplitUInt16

ROOT::Experimental::EColumnType::kUInt64
@ kUInt64

ROOT::Experimental::EColumnType::kSplitInt16
@ kSplitInt16

ROOT::Experimental::EColumnType::kSplitUInt64
@ kSplitUInt64

ROOT::Experimental::EColumnType::kReal32
@ kReal32

ROOT::Experimental::EColumnType::kReal32Trunc
@ kReal32Trunc

ROOT::Experimental::EColumnType::kSplitReal32
@ kSplitReal32

ROOT::Experimental::EColumnType::kInt8
@ kInt8

ROOT::Experimental::EColumnType::kSplitUInt32
@ kSplitUInt32

ROOT::Experimental::EColumnType::kChar
@ kChar

ROOT::Experimental::ClusterSize_t
RClusterSize ClusterSize_t
Definition RNTupleUtil.hxx:145

ROOT::Experimental::kInvalidClusterIndex
constexpr ClusterSize_t kInvalidClusterIndex(std::uint64_t(-1))

ROOT::Experimental::ENTupleStructure
ENTupleStructure
The fields in the ntuple model tree can carry different structural information about the type system.
Definition RNTupleUtil.hxx:114

ROOT::Experimental::kLeaf
@ kLeaf
Definition RNTupleUtil.hxx:114

ROOT::Experimental::kRecord
@ kRecord
Definition RNTupleUtil.hxx:114

ROOT::Experimental::kCollection
@ kCollection
Definition RNTupleUtil.hxx:114

ROOT
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition EExecutionPolicy.hxx:4

ROOT::Experimental::RClusterSize
Wrap the integer in a struct in order to avoid template specialization clash with std::uint64_t.
Definition RNTupleUtil.hxx:120