doc/master/RField_8cxx_source.html

/// \file RField.cxx

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

/// \date 2018-10-15


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

 * 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/RNTupleTypes.hxx>

#include <TClassEdit.h>


#include <algorithm>

#include <cstdint>

#include <cstdlib>

#include <exception>

#include <functional>

#include <iostream>

#include <memory>

#include <string_view>

#include <type_traits>

#include <unordered_set>


void ROOT::Internal::SetAllowFieldSubstitutions(RFieldZero &fieldZero, bool val)

{

   fieldZero.fAllowFieldSubstitutions = val;

}


void ROOT::RFieldZero::Attach(std::unique_ptr<RFieldBase> child)

{

   const std::string childName = child->GetFieldName();

   if (fSubfieldNames.count(childName) > 0)

      throw RException(R__FAIL("duplicate field name: " + childName));

   RFieldBase::Attach(std::move(child), "");

   fSubfieldNames.insert(childName);

}


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

{

   fTraits |= kTraitExtensible;

}


std::unique_ptr<ROOT::RFieldBase> ROOT::RFieldZero::CloneImpl(std::string_view /*newName*/) const

{

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

   for (auto &f : fSubfields) {

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

      result->fSubfieldNames.insert(f->GetFieldName());

   }

   return result;

}


std::vector<std::unique_ptr<ROOT::RFieldBase>> ROOT::RFieldZero::ReleaseSubfields()

{

   std::vector<std::unique_ptr<ROOT::RFieldBase>> result;

   std::swap(fSubfields, result);

   for (auto &f : result)

      f->fParent = nullptr;

   return result;

}


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

{

   visitor.VisitFieldZero(*this);

}


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


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RCardinalityField::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{ENTupleColumnType::kSplitIndex64},

                                                  {ENTupleColumnType::kIndex64},

                                                  {ENTupleColumnType::kSplitIndex32},

                                                  {ENTupleColumnType::kIndex32}},

                                                 {});

   return representations;

}


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

{

   GenerateColumnsImpl<ROOT::Internal::RColumnIndex>(desc);

}


void ROOT::RCardinalityField::ReconcileOnDiskField(const RNTupleDescriptor &desc)

{

   EnsureMatchingOnDiskField(desc, kDiffTypeVersion | kDiffStructure | kDiffTypeName).ThrowOnError();


   const auto &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());

   if (fieldDesc.GetStructure() == ENTupleStructure::kPlain) {

      if (fieldDesc.GetTypeName().rfind("ROOT::RNTupleCardinality<", 0) != 0) {

         throw RException(R__FAIL("RCardinalityField " + GetQualifiedFieldName() +

                                  " expects an on-disk leaf field of the same type\n" +

                                  Internal::GetTypeTraceReport(*this, desc)));

      }

   } else if (fieldDesc.GetStructure() == ENTupleStructure::kCollection) {

      if (!fieldDesc.IsSoACollection() && fieldDesc.GetTypeVersion() != 0) {

         throw RException(R__FAIL("invalid on-disk type version for RCardinalityField " + GetQualifiedFieldName() +

                                  "\n" + Internal::GetTypeTraceReport(*this, desc)));

      }

   } else {

      throw RException(R__FAIL("invalid on-disk structural role for RCardinalityField " + GetQualifiedFieldName() +

                               "\n" + Internal::GetTypeTraceReport(*this, desc)));

   }

}


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

{

   visitor.VisitCardinalityField(*this);

}


const ROOT::RField<ROOT::RNTupleCardinality<std::uint32_t>> *ROOT::RCardinalityField::As32Bit() const

{

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

}


const ROOT::RField<ROOT::RNTupleCardinality<std::uint64_t>> *ROOT::RCardinalityField::As64Bit() const

{

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

}


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


template <typename T>


void ROOT::RSimpleField<T>::ReconcileIntegralField(const RNTupleDescriptor &desc)

{

   EnsureMatchingOnDiskField(desc, kDiffTypeName);


   const RFieldDescriptor &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());

   if (Internal::IsCustomEnumFieldDesc(desc, fieldDesc)) {

      SetOnDiskId(desc.FindFieldId("_0", GetOnDiskId()));

      return;

   }


   static const std::string gIntegralTypeNames[] = {"bool",         "char",          "std::int8_t",  "std::uint8_t",

                                                    "std::int16_t", "std::uint16_t", "std::int32_t", "std::uint32_t",

                                                    "std::int64_t", "std::uint64_t"};

   if (std::find(std::begin(gIntegralTypeNames), std::end(gIntegralTypeNames), fieldDesc.GetTypeName()) ==

       std::end(gIntegralTypeNames)) {

      throw RException(R__FAIL("unexpected on-disk type name '" + fieldDesc.GetTypeName() + "' for field of type '" +

                               GetTypeName() + "'\n" + Internal::GetTypeTraceReport(*this, desc)));

   }

}


template <typename T>


void ROOT::RSimpleField<T>::ReconcileFloatingPointField(const RNTupleDescriptor &desc)

{

   EnsureMatchingOnDiskField(desc, kDiffTypeName);


   const RFieldDescriptor &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());

   if (!(fieldDesc.GetTypeName() == "float" || fieldDesc.GetTypeName() == "double")) {

      throw RException(R__FAIL("unexpected on-disk type name '" + fieldDesc.GetTypeName() + "' for field of type '" +

                               GetTypeName() + "'\n" + Internal::GetTypeTraceReport(*this, desc)));

   }

}


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


template class ROOT::RSimpleField<char>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RField<char>::GetColumnRepresentations() const

{

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

                                                                                {ENTupleColumnType::kUInt8},

                                                                                {ENTupleColumnType::kInt16},

                                                                                {ENTupleColumnType::kUInt16},

                                                                                {ENTupleColumnType::kInt32},

                                                                                {ENTupleColumnType::kUInt32},

                                                                                {ENTupleColumnType::kInt64},

                                                                                {ENTupleColumnType::kUInt64},

                                                                                {ENTupleColumnType::kSplitInt16},

                                                                                {ENTupleColumnType::kSplitUInt16},

                                                                                {ENTupleColumnType::kSplitInt32},

                                                                                {ENTupleColumnType::kSplitUInt32},

                                                                                {ENTupleColumnType::kSplitInt64},

                                                                                {ENTupleColumnType::kSplitUInt64},

                                                                                {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitCharField(*this);

}


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


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


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RField<std::byte>::GetColumnRepresentations() const

{

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

   return representations;

}


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

{

   visitor.VisitByteField(*this);

}


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


template class ROOT::RSimpleField<int8_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::int8_t>::GetColumnRepresentations() const

{

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

                                                                                {ENTupleColumnType::kUInt8},

                                                                                {ENTupleColumnType::kInt16},

                                                                                {ENTupleColumnType::kUInt16},

                                                                                {ENTupleColumnType::kInt32},

                                                                                {ENTupleColumnType::kUInt32},

                                                                                {ENTupleColumnType::kInt64},

                                                                                {ENTupleColumnType::kUInt64},

                                                                                {ENTupleColumnType::kSplitInt16},

                                                                                {ENTupleColumnType::kSplitUInt16},

                                                                                {ENTupleColumnType::kSplitInt32},

                                                                                {ENTupleColumnType::kSplitUInt32},

                                                                                {ENTupleColumnType::kSplitInt64},

                                                                                {ENTupleColumnType::kSplitUInt64},

                                                                                {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitInt8Field(*this);

}


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


template class ROOT::RSimpleField<uint8_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::uint8_t>::GetColumnRepresentations() const

{

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

                                                                                 {ENTupleColumnType::kInt8},

                                                                                 {ENTupleColumnType::kInt16},

                                                                                 {ENTupleColumnType::kUInt16},

                                                                                 {ENTupleColumnType::kInt32},

                                                                                 {ENTupleColumnType::kUInt32},

                                                                                 {ENTupleColumnType::kInt64},

                                                                                 {ENTupleColumnType::kUInt64},

                                                                                 {ENTupleColumnType::kSplitInt16},

                                                                                 {ENTupleColumnType::kSplitUInt16},

                                                                                 {ENTupleColumnType::kSplitInt32},

                                                                                 {ENTupleColumnType::kSplitUInt32},

                                                                                 {ENTupleColumnType::kSplitInt64},

                                                                                 {ENTupleColumnType::kSplitUInt64},

                                                                                 {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitUInt8Field(*this);

}


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


template class ROOT::RSimpleField<bool>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RField<bool>::GetColumnRepresentations() const

{

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

                                                                               {ENTupleColumnType::kInt8},

                                                                               {ENTupleColumnType::kUInt8},

                                                                               {ENTupleColumnType::kInt16},

                                                                               {ENTupleColumnType::kUInt16},

                                                                               {ENTupleColumnType::kInt32},

                                                                               {ENTupleColumnType::kUInt32},

                                                                               {ENTupleColumnType::kInt64},

                                                                               {ENTupleColumnType::kUInt64},

                                                                               {ENTupleColumnType::kSplitInt16},

                                                                               {ENTupleColumnType::kSplitUInt16},

                                                                               {ENTupleColumnType::kSplitInt32},

                                                                               {ENTupleColumnType::kSplitUInt32},

                                                                               {ENTupleColumnType::kSplitInt64},

                                                                               {ENTupleColumnType::kSplitUInt64}});

   return representations;

}


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

{

   visitor.VisitBoolField(*this);

}


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


template class ROOT::RSimpleField<float>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RField<float>::GetColumnRepresentations() const

{

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

                                                  {ENTupleColumnType::kReal32},

                                                  {ENTupleColumnType::kReal16},

                                                  {ENTupleColumnType::kReal32Trunc},

                                                  {ENTupleColumnType::kReal32Quant}},

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

   return representations;

}


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

{

   visitor.VisitFloatField(*this);

}


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


template class ROOT::RSimpleField<double>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RField<double>::GetColumnRepresentations() const

{

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

                                                  {ENTupleColumnType::kReal64},

                                                  {ENTupleColumnType::kSplitReal32},

                                                  {ENTupleColumnType::kReal32},

                                                  {ENTupleColumnType::kReal16},

                                                  {ENTupleColumnType::kReal32Trunc},

                                                  {ENTupleColumnType::kReal32Quant}},

                                                 {});

   return representations;

}


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

{

   visitor.VisitDoubleField(*this);

}


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

{

   fTypeAlias = "Double32_t";

}


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


template class ROOT::RSimpleField<int16_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::int16_t>::GetColumnRepresentations() const

{

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

                                                 {{ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kInt8},

                                                  {ENTupleColumnType::kUInt8},

                                                  {ENTupleColumnType::kUInt16},

                                                  {ENTupleColumnType::kInt32},

                                                  {ENTupleColumnType::kUInt32},

                                                  {ENTupleColumnType::kInt64},

                                                  {ENTupleColumnType::kUInt64},

                                                  {ENTupleColumnType::kSplitUInt16},

                                                  {ENTupleColumnType::kSplitInt32},

                                                  {ENTupleColumnType::kSplitUInt32},

                                                  {ENTupleColumnType::kSplitInt64},

                                                  {ENTupleColumnType::kSplitUInt64},

                                                  {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitInt16Field(*this);

}


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


template class ROOT::RSimpleField<uint16_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::uint16_t>::GetColumnRepresentations() const

{

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

                                                 {{ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kInt8},

                                                  {ENTupleColumnType::kUInt8},

                                                  {ENTupleColumnType::kInt16},

                                                  {ENTupleColumnType::kInt32},

                                                  {ENTupleColumnType::kUInt32},

                                                  {ENTupleColumnType::kInt64},

                                                  {ENTupleColumnType::kUInt64},

                                                  {ENTupleColumnType::kSplitInt16},

                                                  {ENTupleColumnType::kSplitInt32},

                                                  {ENTupleColumnType::kSplitUInt32},

                                                  {ENTupleColumnType::kSplitInt64},

                                                  {ENTupleColumnType::kSplitUInt64},

                                                  {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitUInt16Field(*this);

}


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


template class ROOT::RSimpleField<int32_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::int32_t>::GetColumnRepresentations() const


{


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

                                                 {{ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kInt8},

                                                  {ENTupleColumnType::kUInt8},

                                                  {ENTupleColumnType::kInt16},

                                                  {ENTupleColumnType::kUInt16},

                                                  {ENTupleColumnType::kUInt32},

                                                  {ENTupleColumnType::kInt64},

                                                  {ENTupleColumnType::kUInt64},

                                                  {ENTupleColumnType::kSplitInt16},

                                                  {ENTupleColumnType::kSplitUInt16},

                                                  {ENTupleColumnType::kSplitUInt32},

                                                  {ENTupleColumnType::kSplitInt64},

                                                  {ENTupleColumnType::kSplitUInt64},

                                                  {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitInt32Field(*this);

}


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


template class ROOT::RSimpleField<uint32_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::uint32_t>::GetColumnRepresentations() const

{

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

                                                 {{ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kInt8},

                                                  {ENTupleColumnType::kUInt8},

                                                  {ENTupleColumnType::kInt16},

                                                  {ENTupleColumnType::kUInt16},

                                                  {ENTupleColumnType::kInt32},

                                                  {ENTupleColumnType::kInt64},

                                                  {ENTupleColumnType::kUInt64},

                                                  {ENTupleColumnType::kSplitInt16},

                                                  {ENTupleColumnType::kSplitUInt16},

                                                  {ENTupleColumnType::kSplitInt32},

                                                  {ENTupleColumnType::kSplitInt64},

                                                  {ENTupleColumnType::kSplitUInt64},

                                                  {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitUInt32Field(*this);

}


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


template class ROOT::RSimpleField<uint64_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::uint64_t>::GetColumnRepresentations() const

{

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

                                                 {{ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kInt8},

                                                  {ENTupleColumnType::kUInt8},

                                                  {ENTupleColumnType::kInt16},

                                                  {ENTupleColumnType::kUInt16},

                                                  {ENTupleColumnType::kInt32},

                                                  {ENTupleColumnType::kUInt32},

                                                  {ENTupleColumnType::kInt64},

                                                  {ENTupleColumnType::kSplitInt16},

                                                  {ENTupleColumnType::kSplitUInt16},

                                                  {ENTupleColumnType::kSplitInt32},

                                                  {ENTupleColumnType::kSplitUInt32},

                                                  {ENTupleColumnType::kSplitInt64},

                                                  {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitUInt64Field(*this);

}


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


template class ROOT::RSimpleField<int64_t>;


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RIntegralField<std::int64_t>::GetColumnRepresentations() const

{

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

                                                 {{ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kInt8},

                                                  {ENTupleColumnType::kUInt8},

                                                  {ENTupleColumnType::kInt16},

                                                  {ENTupleColumnType::kUInt16},

                                                  {ENTupleColumnType::kInt32},

                                                  {ENTupleColumnType::kUInt32},

                                                  {ENTupleColumnType::kUInt64},

                                                  {ENTupleColumnType::kSplitInt16},

                                                  {ENTupleColumnType::kSplitUInt16},

                                                  {ENTupleColumnType::kSplitInt32},

                                                  {ENTupleColumnType::kSplitUInt32},

                                                  {ENTupleColumnType::kSplitUInt64},

                                                  {ENTupleColumnType::kBit}});

   return representations;

}


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

{

   visitor.VisitInt64Field(*this);

}


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


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RField<std::string>::GetColumnRepresentations() const

{

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

                                                  {ENTupleColumnType::kIndex64, ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kSplitIndex32, ENTupleColumnType::kChar},

                                                  {ENTupleColumnType::kIndex32, ENTupleColumnType::kChar}},

                                                 {});

   return representations;

}


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

{

   GenerateColumnsImpl<ROOT::Internal::RColumnIndex, char>();

}


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

{

   GenerateColumnsImpl<ROOT::Internal::RColumnIndex, char>(desc);

}


std::size_t ROOT::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::RField<std::string>::ReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to)

{

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

   RNTupleLocalIndex collectionStart;

   ROOT::NTupleSize_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::RField<std::string>::AcceptVisitor(ROOT::Detail::RFieldVisitor &visitor) const

{

   visitor.VisitStringField(*this);

}


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


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

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

     fMaxAlignment(source.fMaxAlignment),

     fSize(source.fSize),

     fOffsets(source.fOffsets)

{

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

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

   fSubfieldNames = source.fSubfieldNames;

   fTraits = source.fTraits;

}


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

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

{

}


std::unique_ptr<ROOT::RFieldBase>


ROOT::Internal::CreateEmulatedRecordField(std::string_view fieldName,

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

                                          std::string_view emulatedFromType)

{

   R__ASSERT(!emulatedFromType.empty());

   return std::unique_ptr<RFieldBase>(new RRecordField(fieldName, std::move(itemFields), emulatedFromType));

}


std::unique_ptr<ROOT::RFieldBase> ROOT::Internal::CreateEmulatedVectorField(std::string_view fieldName,

                                                                            std::unique_ptr<RFieldBase> itemField,

                                                                            std::string_view emulatedFromType)

{

   R__ASSERT(!emulatedFromType.empty());

   return std::unique_ptr<RFieldBase>(new RVectorField(fieldName, std::move(itemField), emulatedFromType));

}


ROOT::RRecordField::RRecordField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields,

                                 std::string_view emulatedFromType)

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

{

   AttachItemFields(std::move(itemFields));

   fTraits |= !emulatedFromType.empty() * kTraitEmulatedField;

}


ROOT::RRecordField::RRecordField(std::string_view fieldName, std::vector<std::unique_ptr<RFieldBase>> itemFields)

   : ROOT::RRecordField(fieldName, std::move(itemFields), "")

{

   fTraits |= kTraitExtensible;

}


void ROOT::RRecordField::AddItem(std::unique_ptr<RFieldBase> item)

{

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

   if (!IsPairOrTuple()) {

      fOffsets.emplace_back(fSize);

   }

   fSize += item->GetValueSize();

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

   fTraits &= item->GetTraits() | (fTraits & kTraitExtensible); // may be called by AddItemToRecord()


   if (IsPairOrTuple()) {

      Attach(std::move(item), "_" + std::to_string(fSubfields.size()));

   } else {

      const std::string itemName = item->GetFieldName();

      if (fSubfieldNames.count(itemName) > 0)

         throw RException(R__FAIL("duplicate field name: " + itemName));

      Attach(std::move(item));

      fSubfieldNames.insert(itemName);

   }

}


void ROOT::Internal::AddItemToRecord(RRecordField &record, std::unique_ptr<RFieldBase> newItem)

{

   // Only supported for untyped records

   assert(record.GetTypeName().empty());

   record.AddItem(std::move(newItem));


   // For nested record fields, we have to reattach all fields of all parents because the modification to the

   // current field will change its size and may change its alignment and hence the layout of all parents.

   auto parent = record.fParent;

   while (parent && typeid(*parent) != typeid(RFieldZero)) {

      // untyped records can only have an untyped record as parent

      assert(dynamic_cast<RRecordField *>(parent) && parent->GetTypeName().empty());


      auto precord = static_cast<RRecordField *>(parent);

      std::vector<std::unique_ptr<ROOT::RFieldBase>> subfields;

      std::swap(precord->fSubfields, subfields);

      precord->fTraits = ROOT::RFieldBase::kTraitExtensible;

      precord->fSubfieldNames.clear();

      precord->fMaxAlignment = 1;

      precord->fSize = 0;

      precord->fOffsets.clear();

      precord->AttachItemFields(std::move(subfields));


      parent = precord->fParent;

   }

}


std::size_t ROOT::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::RFieldBase> ROOT::RRecordField::CloneImpl(std::string_view newName) const

{

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

}


std::size_t ROOT::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::RRecordField::ReadGlobalImpl(ROOT::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::RRecordField::ReadInClusterImpl(RNTupleLocalIndex localIndex, void *to)

{

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

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

   }

}


void ROOT::RRecordField::ReconcileOnDiskField(const RNTupleDescriptor &desc)

{

   if (fTraits & kTraitEmulatedField) {

      // The field has been explicitly constructed following the on-disk information. No further reconcilation needed.

      return;

   }

   // Note that the RPairField and RTupleField descendants have their own reconcilation logic

   R__ASSERT(GetTypeName().empty());


   EnsureMatchingOnDiskField(desc, kDiffTypeName | kDiffTypeVersion).ThrowOnError();


   // The on-disk ID of subfields is matched by field name. So we inherently support reordering of fields

   // and we will ignore extra on-disk fields.

   // It remains to mark the extra in-memory fields as artificial.

   const auto &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());

   std::unordered_set<std::string_view> onDiskSubfields;

   for (const auto &subField : desc.GetFieldIterable(fieldDesc)) {

      onDiskSubfields.insert(subField.GetFieldName());

   }

   for (auto &f : fSubfields) {

      if (onDiskSubfields.count(f->GetFieldName()) == 0)

         CallSetArtificialOn(*f);

   }

}


void ROOT::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::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::RFieldBase::RDeleter> ROOT::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, GetAlignment());

}


std::vector<ROOT::RFieldBase::RValue> ROOT::RRecordField::SplitValue(const RValue &value) const

{

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

   auto charPtr = static_cast<unsigned char *>(valuePtr.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>(valuePtr, charPtr + fOffsets[i])));

   }

   return result;

}


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

{

   visitor.VisitRecordField(*this);

}


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


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

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

                      false /* isSimple */, N),

     fN(N)

{

   fTraits |= kTraitTriviallyDestructible;

}


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RBitsetField::GetColumnRepresentations() const

{

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

   return representations;

}


void ROOT::RBitsetField::GenerateColumns()

{

   GenerateColumnsImpl<bool>();

}


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

{

   GenerateColumnsImpl<bool>(desc);

}


template <typename FUlong, typename FUlonglong, typename... Args>


void ROOT::RBitsetField::SelectWordSize(FUlong &&fUlong, FUlonglong &&fUlonglong, Args &&...args)

{

   if (WordSize() == sizeof(unsigned long)) {

      fUlong(std::forward<Args>(args)..., fN, *fPrincipalColumn);

   } else if (WordSize() == sizeof(unsigned long long)) {

      // NOTE: this can only happen on Windows; see the comment on the RBitsetField class.

      fUlonglong(std::forward<Args>(args)..., fN, *fPrincipalColumn);

   } else {

      R__ASSERT(false);

   }

}


template <typename Word_t>


static void BitsetAppendImpl(const void *from, size_t nBits, ROOT::Internal::RColumn &column)

{

   constexpr auto kBitsPerWord = sizeof(Word_t) * 8;

   // Process bits in stack-buffered chunks using AppendV to reduce per-element call overhead.

   constexpr std::size_t kChunkSize = 256;

   bool buffer[kChunkSize];


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

   std::size_t bitIdx = 0;

   while (bitIdx < nBits) {

      const std::size_t nBatch = std::min(kChunkSize, nBits - bitIdx);

      for (std::size_t b = 0; b < nBatch; ++b) {

         const std::size_t currentBit = bitIdx + b;

         buffer[b] =

            (asWordArray[currentBit / kBitsPerWord] & (static_cast<Word_t>(1) << (currentBit % kBitsPerWord))) != 0;

      }

      column.AppendV(buffer, nBatch);

      bitIdx += nBatch;

   }

}


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

{

   SelectWordSize(BitsetAppendImpl<unsigned long>, BitsetAppendImpl<unsigned long long>, from);

   return fN;

}


template <typename Word_t>

static void


BitsetReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to, size_t nBits, ROOT::Internal::RColumn &column)

{

   constexpr auto kBitsPerWord = sizeof(Word_t) * 8;

   // Read column values into a local buffer in chunks via ReadV, then unpack them into bitset words.

   constexpr std::size_t kChunkSize = 256;

   bool buffer[kChunkSize];


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

   std::size_t bitIdx = 0;

   while (bitIdx < nBits) {

      const std::size_t nBatch = std::min(kChunkSize, nBits - bitIdx);

      column.ReadV(globalIndex * nBits + bitIdx, nBatch, buffer);

      for (std::size_t b = 0; b < nBatch; ++b) {

         const std::size_t currentBit = bitIdx + b;

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

         const Word_t bit = static_cast<Word_t>(buffer[b]) << (currentBit % kBitsPerWord);

         asWordArray[currentBit / kBitsPerWord] = (asWordArray[currentBit / kBitsPerWord] & ~mask) | bit;

      }

      bitIdx += nBatch;

   }

}


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

{

   SelectWordSize(BitsetReadGlobalImpl<unsigned long>, BitsetReadGlobalImpl<unsigned long long>, globalIndex, to);

}


template <typename Word_t>

static void


BitsetReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to, size_t nBits, ROOT::Internal::RColumn &column)

{

   constexpr auto kBitsPerWord = sizeof(Word_t) * 8;

   constexpr std::size_t kChunkSize = 256;

   bool buffer[kChunkSize];


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

   std::size_t bitIdx = 0;

   while (bitIdx < nBits) {

      const std::size_t nBatch = std::min(kChunkSize, nBits - bitIdx);

      column.ReadV(ROOT::RNTupleLocalIndex(localIndex.GetClusterId(), localIndex.GetIndexInCluster() * nBits + bitIdx),

                   nBatch, buffer);

      for (std::size_t b = 0; b < nBatch; ++b) {

         const std::size_t currentBit = bitIdx + b;

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

         const Word_t bit = static_cast<Word_t>(buffer[b]) << (currentBit % kBitsPerWord);

         asWordArray[currentBit / kBitsPerWord] = (asWordArray[currentBit / kBitsPerWord] & ~mask) | bit;

      }

      bitIdx += nBatch;

   }

}


void ROOT::RBitsetField::ReadInClusterImpl(RNTupleLocalIndex localIndex, void *to)

{

   SelectWordSize(BitsetReadInClusterImpl<unsigned long>, BitsetReadInClusterImpl<unsigned long long>, localIndex, to);

}


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

{

   visitor.VisitBitsetField(*this);

}


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


ROOT::RNullableField::RNullableField(std::string_view fieldName, const std::string &typePrefix,

                                     std::unique_ptr<RFieldBase> itemField)

   : ROOT::RFieldBase(fieldName, typePrefix + "<" + itemField->GetTypeName() + ">", ROOT::ENTupleStructure::kCollection,

                      false /* isSimple */)

{

   if (!itemField->GetTypeAlias().empty())

      fTypeAlias = typePrefix + "<" + itemField->GetTypeAlias() + ">";


   Attach(std::move(itemField), "_0");

}


const ROOT::RFieldBase::RColumnRepresentations &ROOT::RNullableField::GetColumnRepresentations() const

{

   static RColumnRepresentations representations({{ENTupleColumnType::kSplitIndex64},

                                                  {ENTupleColumnType::kIndex64},

                                                  {ENTupleColumnType::kSplitIndex32},

                                                  {ENTupleColumnType::kIndex32}},

                                                 {{}});

   return representations;

}


void ROOT::RNullableField::GenerateColumns()

{

   R__ASSERT(!fIsEvolvedFromInnerType);

   GenerateColumnsImpl<ROOT::Internal::RColumnIndex>();

}


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

{

   if (!fIsEvolvedFromInnerType)

      GenerateColumnsImpl<ROOT::Internal::RColumnIndex>(desc);

}


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

{

   fPrincipalColumn->Append(&fNWritten);

   return sizeof(ROOT::Internal::RColumnIndex);

}


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

{

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

   fNWritten++;

   fPrincipalColumn->Append(&fNWritten);

   return sizeof(ROOT::Internal::RColumnIndex) + nbytesItem;

}


void ROOT::RNullableField::ReconcileOnDiskField(const RNTupleDescriptor &desc)

{

   static const std::vector<std::string> prefixes = {"std::optional<", "std::unique_ptr<"};


   auto success = EnsureMatchingOnDiskField(desc, kDiffTypeName);

   if (!success) {

      fIsEvolvedFromInnerType = true;

   } else {

      success = EnsureMatchingTypePrefix(desc, prefixes);

      fIsEvolvedFromInnerType = !success;

   }


   if (fIsEvolvedFromInnerType)

      fSubfields[0]->SetOnDiskId(GetOnDiskId());

}


ROOT::RNTupleLocalIndex ROOT::RNullableField::GetItemIndex(ROOT::NTupleSize_t globalIndex)

{

   RNTupleLocalIndex collectionStart;

   ROOT::NTupleSize_t collectionSize;

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

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

}


ROOT::RNTupleLocalIndex ROOT::RNullableField::GetItemIndex(ROOT::RNTupleLocalIndex localIndex)

{

   RNTupleLocalIndex collectionStart;

   ROOT::NTupleSize_t collectionSize;

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

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

}


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

{

   visitor.VisitNullableField(*this);

}


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


namespace {

// Dummy class to determine the dynamic type of any polymorphic user object.

struct PolymorphicClass {

   virtual ~PolymorphicClass() = default;

};

} // namespace


ROOT::RUniquePtrField::RUniquePtrField(std::string_view fieldName, std::unique_ptr<RFieldBase> itemField)

   : RNullableField(fieldName, "std::unique_ptr", std::move(itemField)), fItemDeleter(GetDeleterOf(*fSubfields[0]))

{

   if (const auto *classField = dynamic_cast<const ROOT::RClassField *>(fSubfields[0].get())) {

      fPolymorphicTypeInfo = classField->GetPolymorphicTypeInfo();

   }

}


std::unique_ptr<ROOT::RFieldBase> ROOT::RUniquePtrField::CloneImpl(std::string_view newName) const

{

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

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

}


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

{

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

   if (*typedValue) {

      const void *obj = typedValue->get();

      if (fPolymorphicTypeInfo != nullptr) {

         // This cast allows getting the dynamic type of polymorphic objects. A similar strategy is employed by

         // TIsAProxy. If one of them needs updating because of changes in C++, also check the other one.

         const std::type_info &t = typeid(*static_cast<const PolymorphicClass *>(obj));

         if (t != *fPolymorphicTypeInfo) {

            std::string msg = "invalid dynamic type of object, expected " + fSubfields[0]->GetTypeName();

            int err = 0;

            char *demangled = TClassEdit::DemangleTypeIdName(t, err);

            if (!err) {

               msg = msg + " but was passed " + demangled;

               free(demangled);

            }

            msg += " and upcasting of polymorphic types is not supported in RNTuple";

            throw RException(R__FAIL(msg));

         }

      }

      return AppendValue(obj);

   } else {

      return AppendNull();

   }

}


void *ROOT::RUniquePtrField::PrepareRead(void *to, bool hasOnDiskValue)

{

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

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


   void *valuePtr = nullptr;

   if (isValidValue)

      valuePtr = ptr->get();


   if (isValidValue && !hasOnDiskValue) {

      ptr->release();

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

      valuePtr = nullptr;

   } else if (!isValidValue && hasOnDiskValue) {

      valuePtr = CallCreateObjectRawPtrOn(*fSubfields[0]);

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

   }


   return valuePtr;

}


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

{

   RNTupleLocalIndex itemIndex;

   if (!fIsEvolvedFromInnerType)

      itemIndex = GetItemIndex(globalIndex);

   const bool hasOnDiskValue = fIsEvolvedFromInnerType || itemIndex.GetIndexInCluster() != ROOT::kInvalidNTupleIndex;

   auto valuePtr = PrepareRead(to, hasOnDiskValue);

   if (hasOnDiskValue) {

      if (fIsEvolvedFromInnerType) {

         CallReadOn(*fSubfields[0], globalIndex, valuePtr);

      } else {

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

      }

   }

}


void ROOT::RUniquePtrField::ReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to)

{

   RNTupleLocalIndex itemIndex;

   if (!fIsEvolvedFromInnerType) {

      itemIndex = GetItemIndex(localIndex);

   } else {

      itemIndex = localIndex;

   }

   const bool hasOnDiskValue = itemIndex.GetIndexInCluster() != ROOT::kInvalidNTupleIndex;

   auto valuePtr = PrepareRead(to, hasOnDiskValue);

   if (hasOnDiskValue)

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

}


void ROOT::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::RFieldBase::RDeleter> ROOT::RUniquePtrField::GetDeleter() const

{

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

}


std::vector<ROOT::RFieldBase::RValue> ROOT::RUniquePtrField::SplitValue(const RValue &value) const

{

   std::vector<RValue> result;

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

   const auto &uniquePtr = *static_cast<std::unique_ptr<char> *>(valuePtr.get());

   if (uniquePtr) {

      result.emplace_back(fSubfields[0]->BindValue(std::shared_ptr<void>(valuePtr, uniquePtr.get())));

   }

   return result;

}


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


ROOT::ROptionalField::ROptionalField(std::string_view fieldName, std::unique_ptr<RFieldBase> itemField)

   : RNullableField(fieldName, "std::optional", std::move(itemField)), fItemDeleter(GetDeleterOf(*fSubfields[0]))

{

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

      fTraits |= kTraitTriviallyDestructible;

}


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

{

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

}


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

{

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

}


std::unique_ptr<ROOT::RFieldBase> ROOT::ROptionalField::CloneImpl(std::string_view newName) const

{

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

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

}


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

{

   if (*GetEngagementPtr(from)) {

      return AppendValue(from);

   } else {

      return AppendNull();

   }

}


void ROOT::ROptionalField::PrepareRead(void *to, bool hasOnDiskValue)

{

   auto engagementPtr = GetEngagementPtr(to);

   if (hasOnDiskValue) {

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

         CallConstructValueOn(*fSubfields[0], to);

      *engagementPtr = true;

   } else {

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

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

      *engagementPtr = false;

   }

}


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

{

   RNTupleLocalIndex itemIndex;

   if (!fIsEvolvedFromInnerType)

      itemIndex = GetItemIndex(globalIndex);

   const bool hasOnDiskValue = fIsEvolvedFromInnerType || itemIndex.GetIndexInCluster() != ROOT::kInvalidNTupleIndex;

   PrepareRead(to, hasOnDiskValue);

   if (hasOnDiskValue) {

      if (fIsEvolvedFromInnerType) {

         CallReadOn(*fSubfields[0], globalIndex, to);

      } else {

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

      }

   }

}


void ROOT::ROptionalField::ReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to)

{

   RNTupleLocalIndex itemIndex;

   if (!fIsEvolvedFromInnerType) {

      itemIndex = GetItemIndex(localIndex);

   } else {

      itemIndex = localIndex;

   }

   const bool hasOnDiskValue = itemIndex.GetIndexInCluster() != ROOT::kInvalidNTupleIndex;

   PrepareRead(to, hasOnDiskValue);

   if (hasOnDiskValue)

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

}


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

{

   *GetEngagementPtr(where) = false;

}


void ROOT::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::RFieldBase::RDeleter> ROOT::ROptionalField::GetDeleter() const

{

   return std::make_unique<ROptionalDeleter>(

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

      fSubfields[0]->GetValueSize(), GetAlignment());

}


std::vector<ROOT::RFieldBase::RValue> ROOT::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::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::ROptionalField::GetAlignment() const

{

   return fSubfields[0]->GetAlignment();

}


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


ROOT::RAtomicField::RAtomicField(std::string_view fieldName, std::unique_ptr<RFieldBase> itemField)

   : RFieldBase(fieldName, "std::atomic<" + itemField->GetTypeName() + ">", ROOT::ENTupleStructure::kPlain,

                false /* isSimple */)

{

   if (itemField->GetTraits() & kTraitTriviallyConstructible)

      fTraits |= kTraitTriviallyConstructible;

   if (itemField->GetTraits() & kTraitTriviallyDestructible)

      fTraits |= kTraitTriviallyDestructible;


   if (!itemField->GetTypeAlias().empty())

      fTypeAlias = "std::atomic<" + itemField->GetTypeAlias() + ">";


   Attach(std::move(itemField), "_0");

}


std::unique_ptr<ROOT::RFieldBase> ROOT::RAtomicField::CloneImpl(std::string_view newName) const

{

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

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

}


void ROOT::RAtomicField::ReconcileOnDiskField(const RNTupleDescriptor &desc)

{

   const auto &fieldDesc = desc.GetFieldDescriptor(GetOnDiskId());

   if (fieldDesc.GetTypeName().rfind("std::atomic<", 0) == 0) {

      EnsureMatchingOnDiskField(desc, kDiffTypeName).ThrowOnError();

   } else {

      fSubfields[0]->SetOnDiskId(GetOnDiskId());

   }

}


std::vector<ROOT::RFieldBase::RValue> ROOT::RAtomicField::SplitValue(const RValue &value) const

{

   std::vector<RValue> result;

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

   return result;

}


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

{

   visitor.VisitAtomicField(*this);

}


free
free(fBuffer)

fSize
dim_t fSize
Definition DeclareExecutors.h:185

RColumn.hxx

REntry.hxx

RError.hxx

R__FAIL
#define R__FAIL(msg)
Short-hand to return an RResult<T> in an error state; the RError is implicitly converted into RResult...
Definition RError.hxx:322

RFieldVisitor.hxx

BitsetReadGlobalImpl
static void BitsetReadGlobalImpl(ROOT::NTupleSize_t globalIndex, void *to, size_t nBits, ROOT::Internal::RColumn &column)
Definition RField.cxx:842

BitsetReadInClusterImpl
static void BitsetReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to, size_t nBits, ROOT::Internal::RColumn &column)
Definition RField.cxx:871

BitsetAppendImpl
static void BitsetAppendImpl(const void *from, size_t nBits, ROOT::Internal::RColumn &column)
Definition RField.cxx:813

RField.hxx

RLogger.hxx

RNTupleModel.hxx

RNTupleSerialize.hxx

RNTupleTypes.hxx

b
#define b(i)
Definition RSha256.hxx:100

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

TClassEdit.h

R__ASSERT
#define R__ASSERT(e)
Checks condition e and reports a fatal error if it's false.
Definition TError.h:139

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:181

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:177

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:248

child
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 child
Definition TGWin32VirtualXProxy.cxx:183

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

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

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

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

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

ROOT::Detail::RFieldVisitor::VisitByteField
virtual void VisitByteField(const ROOT::RField< std::byte > &field)
Definition RFieldVisitor.hxx:78

ROOT::Detail::RFieldVisitor::VisitInt64Field
virtual void VisitInt64Field(const ROOT::RIntegralField< std::int64_t > &field)
Definition RFieldVisitor.hxx:85

ROOT::Detail::RFieldVisitor::VisitInt8Field
virtual void VisitInt8Field(const ROOT::RIntegralField< std::int8_t > &field)
Definition RFieldVisitor.hxx:82

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

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

ROOT::Detail::RFieldVisitor::VisitUInt32Field
virtual void VisitUInt32Field(const ROOT::RIntegralField< std::uint32_t > &field)
Definition RFieldVisitor.hxx:90

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

ROOT::Detail::RFieldVisitor::VisitInt32Field
virtual void VisitInt32Field(const ROOT::RIntegralField< std::int32_t > &field)
Definition RFieldVisitor.hxx:84

ROOT::Detail::RFieldVisitor::VisitUInt8Field
virtual void VisitUInt8Field(const ROOT::RIntegralField< std::uint8_t > &field)
Definition RFieldVisitor.hxx:88

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

ROOT::Detail::RFieldVisitor::VisitStringField
virtual void VisitStringField(const ROOT::RField< std::string > &field)
Definition RFieldVisitor.hxx:87

ROOT::Detail::RFieldVisitor::VisitUInt16Field
virtual void VisitUInt16Field(const ROOT::RIntegralField< std::uint16_t > &field)
Definition RFieldVisitor.hxx:89

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

ROOT::Detail::RFieldVisitor::VisitInt16Field
virtual void VisitInt16Field(const ROOT::RIntegralField< std::int16_t > &field)
Definition RFieldVisitor.hxx:83

ROOT::Detail::RFieldVisitor::VisitUInt64Field
virtual void VisitUInt64Field(const ROOT::RIntegralField< std::uint64_t > &field)
Definition RFieldVisitor.hxx:91

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

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

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

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

ROOT::Internal::RColumnIndex
The in-memory representation of a 32bit or 64bit on-disk index column.
Definition RNTupleTypes.hxx:332

ROOT::Internal::RColumn
A column is a storage-backed array of a simple, fixed-size type, from which pages can be mapped into ...
Definition RColumn.hxx:37

ROOT::Internal::RColumn::AppendV
void AppendV(const void *from, std::size_t count)
Definition RColumn.hxx:137

ROOT::Internal::RColumn::ReadV
void ReadV(ROOT::NTupleSize_t globalIndex, ROOT::NTupleSize_t count, void *to)
Definition RColumn.hxx:180

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

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

ROOT::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:1262

ROOT::RAtomicField::ReconcileOnDiskField
void ReconcileOnDiskField(const RNTupleDescriptor &desc) final
For non-artificial fields, check compatibility of the in-memory field and the on-disk field.
Definition RField.cxx:1268

ROOT::RAtomicField::SplitValue
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:1278

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

ROOT::RBitsetField::ReadInClusterImpl
void ReadInClusterImpl(RNTupleLocalIndex localIndex, void *to) final
Definition RField.cxx:893

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

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

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

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

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

ROOT::RBitsetField::SelectWordSize
void SelectWordSize(FUlong &&fUlong, FUlonglong &&fUlonglong, Args &&...args)
Definition RField.cxx:800

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

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

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

ROOT::RCardinalityField::ReconcileOnDiskField
void ReconcileOnDiskField(const RNTupleDescriptor &desc) final
For non-artificial fields, check compatibility of the in-memory field and the on-disk field.
Definition RField.cxx:95

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

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

ROOT::RClassField
The field for a class with dictionary.
Definition RField.hxx:184

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

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

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

ROOT::RException
Base class for all ROOT issued exceptions.
Definition RError.hxx:78

ROOT::RFieldBase::RColumnRepresentations
The list of column representations a field can have.
Definition RFieldBase.hxx:208

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

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

ROOT::RFieldBase::Attach
void Attach(std::unique_ptr< RFieldBase > child, std::string_view expectedChildName="")
Add a new subfield to the list of nested fields.
Definition RFieldBase.cxx:678

ROOT::RFieldBase::fSubfields
std::vector< std::unique_ptr< RFieldBase > > fSubfields
Collections and classes own subfields.
Definition RFieldBase.hxx:315

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

ROOT::RFieldBase::GetConstSubfields
std::vector< const RFieldBase * > GetConstSubfields() const
Definition RFieldBase.cxx:718

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

ROOT::RFieldBase::kTraitEmulatedField
@ kTraitEmulatedField
This field is a user defined type that was missing dictionaries and was reconstructed from the on-dis...
Definition RFieldBase.hxx:169

ROOT::RFieldBase::kTraitTriviallyDestructible
@ kTraitTriviallyDestructible
The type is cleaned up just by freeing its memory. I.e. the destructor performs a no-op.
Definition RFieldBase.hxx:159

ROOT::RFieldBase::kTraitExtensible
@ kTraitExtensible
Can attach new item fields even when already connected.
Definition RFieldBase.hxx:171

ROOT::RFieldBase::kTraitTriviallyConstructible
@ kTraitTriviallyConstructible
No constructor needs to be called, i.e.
Definition RFieldBase.hxx:157

ROOT::RFieldBase::fTraits
std::uint32_t fTraits
Properties of the type that allow for optimizations of collections of that type.
Definition RFieldBase.hxx:332

ROOT::RFieldBase::fParent
RFieldBase * fParent
Subfields point to their mother field.
Definition RFieldBase.hxx:317

ROOT::RFieldBase::fTypeAlias
std::string fTypeAlias
A typedef or using name that was used when creating the field.
Definition RFieldBase.hxx:334

ROOT::RFieldBase::GetTraits
std::uint32_t GetTraits() const
Definition RFieldBase.hxx:647

ROOT::RFieldBase::GetTypeName
const std::string & GetTypeName() const
Definition RFieldBase.hxx:653

ROOT::RFieldDescriptor
Metadata stored for every field of an RNTuple.
Definition RNTupleDescriptor.hxx:122

ROOT::RFieldDescriptor::GetTypeName
const std::string & GetTypeName() const
Definition RNTupleDescriptor.hxx:191

ROOT::RFieldZero
The container field for an ntuple model, which itself has no physical representation.
Definition RField.hxx:58

ROOT::RFieldZero::fSubfieldNames
std::unordered_set< std::string > fSubfieldNames
Efficient detection of duplicate field names.
Definition RField.hxx:71

ROOT::RFieldZero::RFieldZero
RFieldZero()
Definition RField.cxx:49

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

ROOT::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:54

ROOT::RFieldZero::ReleaseSubfields
std::vector< std::unique_ptr< RFieldBase > > ReleaseSubfields()
Moves all subfields into the returned vector.
Definition RField.cxx:64

ROOT::RFieldZero::fAllowFieldSubstitutions
bool fAllowFieldSubstitutions
If field substitutions are allowed, upon connecting to a page source the field hierarchy will replace...
Definition RField.hxx:69

ROOT::RFieldZero::Attach
void Attach(std::unique_ptr< RFieldBase > child)
A public version of the Attach method that allows piece-wise construction of the zero field.
Definition RField.cxx:40

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

ROOT::RIntegralField
Definition RFieldFundamental.hxx:101

ROOT::RNTupleDescriptor
The on-storage metadata of an RNTuple.
Definition RNTupleDescriptor.hxx:709

ROOT::RNTupleDescriptor::GetFieldIterable
RFieldDescriptorIterable GetFieldIterable(const RFieldDescriptor &fieldDesc) const
Definition RNTupleDescriptor.cxx:1487

ROOT::RNTupleDescriptor::GetFieldDescriptor
const RFieldDescriptor & GetFieldDescriptor(ROOT::DescriptorId_t fieldId) const
Definition RNTupleDescriptor.hxx:864

ROOT::RNTupleDescriptor::FindFieldId
ROOT::DescriptorId_t FindFieldId(std::string_view fieldName, ROOT::DescriptorId_t parentId) const
Definition RNTupleDescriptor.cxx:378

ROOT::RNTupleLocalIndex
Addresses a column element or field item relative to a particular cluster, instead of a global NTuple...
Definition RNTupleTypes.hxx:137

ROOT::RNTupleLocalIndex::GetIndexInCluster
ROOT::NTupleSize_t GetIndexInCluster() const
Definition RNTupleTypes.hxx:187

ROOT::RNTupleLocalIndex::GetClusterId
ROOT::DescriptorId_t GetClusterId() const
Definition RNTupleTypes.hxx:186

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

ROOT::RNullableField::ReconcileOnDiskField
void ReconcileOnDiskField(const RNTupleDescriptor &desc) final
For non-artificial fields, check compatibility of the in-memory field and the on-disk field.
Definition RField.cxx:952

ROOT::RNullableField::GetItemIndex
RNTupleLocalIndex GetItemIndex(NTupleSize_t globalIndex)
Given the global index of the nullable field, returns the corresponding cluster-local index of the su...
Definition RField.cxx:968

ROOT::RNullableField::RNullableField
RNullableField(std::string_view fieldName, const std::string &typePrefix, std::unique_ptr< RFieldBase > itemField)
Definition RField.cxx:905

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

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

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

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

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

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

ROOT::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:1194

ROOT::ROptionalField::GetAlignment
std::size_t GetAlignment() const final
What alignof(T) for this type returns.
Definition RField.cxx:1240

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

ROOT::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:1135

ROOT::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:1130

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

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

ROOT::ROptionalField::ReadInClusterImpl
void ReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to) final
Definition RField.cxx:1180

ROOT::ROptionalField::SplitValue
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:1216

ROOT::ROptionalField::GetValueSize
std::size_t GetValueSize() const final
What sizeof(T) for this type returns.
Definition RField.cxx:1226

ROOT::ROptionalField::PrepareRead
void PrepareRead(void *to, bool hasOnDiskValue)
Definition RField.cxx:1150

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

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

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

ROOT::RRecordField::SplitValue
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:756

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

ROOT::RRecordField::ReadInClusterImpl
void ReadInClusterImpl(RNTupleLocalIndex localIndex, void *to) final
Definition RField.cxx:699

ROOT::RRecordField::fSubfieldNames
std::unordered_set< std::string > fSubfieldNames
Efficient detection of duplicate field names.
Definition RFieldRecord.hxx:69

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

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

ROOT::RRecordField::AttachItemFields
void AttachItemFields(ContainerT &&itemFields)
Definition RFieldRecord.hxx:110

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

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

ROOT::RRecordField::AddItem
void AddItem(std::unique_ptr< RFieldBase > item)
Adds an additional item field.
Definition RField.cxx:620

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

ROOT::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:731

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

ROOT::RRecordField::ReconcileOnDiskField
void ReconcileOnDiskField(const RNTupleDescriptor &desc) override
For non-artificial fields, check compatibility of the in-memory field and the on-disk field.
Definition RField.cxx:706

ROOT::RSimpleField
Definition RField.hxx:407

ROOT::RSimpleField::ReconcileIntegralField
void ReconcileIntegralField(const RNTupleDescriptor &desc)
Definition RField.cxx:135

ROOT::RSimpleField::ReconcileFloatingPointField
void ReconcileFloatingPointField(const RNTupleDescriptor &desc)
Definition RField.cxx:156

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

ROOT::RUniquePtrField::SplitValue
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:1105

ROOT::RUniquePtrField::fPolymorphicTypeInfo
const std::type_info * fPolymorphicTypeInfo
If the item type is a polymorphic class (that declares or inherits at least one virtual method),...
Definition RFieldSTLMisc.hxx:289

ROOT::RUniquePtrField::PrepareRead
void * PrepareRead(void *to, bool hasOnDiskValue)
Definition RField.cxx:1039

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

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

ROOT::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:1006

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

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

ROOT::RUniquePtrField::ReadInClusterImpl
void ReadInClusterImpl(ROOT::RNTupleLocalIndex localIndex, void *to) final
Definition RField.cxx:1076

ROOT::RVectorField
Template specializations for C++ std::vector.
Definition RFieldSequenceContainer.hxx:213

bool

ROOT::Internal::SetAllowFieldSubstitutions
void SetAllowFieldSubstitutions(RFieldZero &fieldZero, bool val)
Definition RField.cxx:35

ROOT::Internal::CreateEmulatedVectorField
std::unique_ptr< RFieldBase > CreateEmulatedVectorField(std::string_view fieldName, std::unique_ptr< RFieldBase > itemField, std::string_view emulatedFromType)
Definition RField.cxx:598

ROOT::Internal::CreateEmulatedRecordField
std::unique_ptr< RFieldBase > CreateEmulatedRecordField(std::string_view fieldName, std::vector< std::unique_ptr< RFieldBase > > itemFields, std::string_view emulatedFromType)
Definition RField.cxx:590

ROOT::Internal::GetTypeTraceReport
std::string GetTypeTraceReport(const RFieldBase &field, const RNTupleDescriptor &desc)
Prints the hierarchy of types with their field names and field IDs for the given in-memory field and ...
Definition RFieldUtils.cxx:771

ROOT::Internal::AddItemToRecord
void AddItemToRecord(RRecordField &record, std::unique_ptr< RFieldBase > newItem)
Definition RField.cxx:641

ROOT::Internal::IsCustomEnumFieldDesc
bool IsCustomEnumFieldDesc(const RNTupleDescriptor &desc, const RFieldDescriptor &fieldDesc)
Tells if the field describes a user-defined enum type.
Definition RNTupleDescriptor.cxx:1583

ROOT
Definition EExecutionPolicy.hxx:4

ROOT::kInvalidNTupleIndex
constexpr NTupleSize_t kInvalidNTupleIndex
Definition RNTupleTypes.hxx:130

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

ROOT::ENTupleStructure
ENTupleStructure
The fields in the RNTuple data model tree can carry different structural information about the type s...
Definition RNTupleTypes.hxx:106

ROOT::ENTupleStructure::kRecord
@ kRecord

ROOT::ENTupleStructure::kCollection
@ kCollection

ROOT::ENTupleStructure::kPlain
@ kPlain

ROOT::ENTupleColumnType::kUInt8
@ kUInt8

ROOT::ENTupleColumnType::kByte
@ kByte

ROOT::ENTupleColumnType::kInt32
@ kInt32

ROOT::ENTupleColumnType::kSplitReal64
@ kSplitReal64

ROOT::ENTupleColumnType::kInt64
@ kInt64

ROOT::ENTupleColumnType::kBit
@ kBit

ROOT::ENTupleColumnType::kReal64
@ kReal64

ROOT::ENTupleColumnType::kSplitInt64
@ kSplitInt64

ROOT::ENTupleColumnType::kReal32Quant
@ kReal32Quant

ROOT::ENTupleColumnType::kReal16
@ kReal16

ROOT::ENTupleColumnType::kUInt32
@ kUInt32

ROOT::ENTupleColumnType::kInt16
@ kInt16

ROOT::ENTupleColumnType::kSplitIndex64
@ kSplitIndex64

ROOT::ENTupleColumnType::kSplitIndex32
@ kSplitIndex32

ROOT::ENTupleColumnType::kIndex32
@ kIndex32

ROOT::ENTupleColumnType::kIndex64
@ kIndex64

ROOT::ENTupleColumnType::kSplitInt32
@ kSplitInt32

ROOT::ENTupleColumnType::kUInt16
@ kUInt16

ROOT::ENTupleColumnType::kSplitUInt16
@ kSplitUInt16

ROOT::ENTupleColumnType::kUInt64
@ kUInt64

ROOT::ENTupleColumnType::kSplitInt16
@ kSplitInt16

ROOT::ENTupleColumnType::kSplitUInt64
@ kSplitUInt64

ROOT::ENTupleColumnType::kReal32
@ kReal32

ROOT::ENTupleColumnType::kReal32Trunc
@ kReal32Trunc

ROOT::ENTupleColumnType::kSplitReal32
@ kSplitReal32

ROOT::ENTupleColumnType::kInt8
@ kInt8

ROOT::ENTupleColumnType::kSplitUInt32
@ kSplitUInt32

ROOT::ENTupleColumnType::kChar
@ kChar

TClassEdit::DemangleTypeIdName
char * DemangleTypeIdName(const std::type_info &ti, int &errorCode)
Demangle in a portable way the type id name.
Definition TClassEdit.cxx:2255