[ntuple] EColumnType --> ENTupleColumnType

Author: jblomer

tree/dataframe/src/RNTupleDS.cxx

@@ -79,9 +79,11 @@ class RRDFCardinalityField final : public ROOT::Experimental::RFieldBase {
 
    const RColumnRepresentations &GetColumnRepresentations() const final
    {
-      static RColumnRepresentations representations(
-         {{EColumnType::kSplitIndex64}, {EColumnType::kIndex64}, {EColumnType::kSplitIndex32}, {EColumnType::kIndex32}},
-         {});
+      static RColumnRepresentations representations({{ENTupleColumnType::kSplitIndex64},
+                                                     {ENTupleColumnType::kIndex64},
+                                                     {ENTupleColumnType::kSplitIndex32},
+                                                     {ENTupleColumnType::kIndex32}},
+                                                    {});
       return representations;
    }
    // Field is only used for reading

tree/ntuple/v7/inc/ROOT/RColumn.hxx

@@ -39,7 +39,7 @@ namespace ROOT::Experimental::Internal {
 // clang-format on
 class RColumn {
 private:
-   EColumnType fType;
+   ENTupleColumnType fType;
    /// Columns belonging to the same field are distinguished by their order.  E.g. for an std::string field, there is
    /// the offset column with index 0 and the character value column with index 1.
    std::uint32_t fIndex;
@@ -74,7 +74,7 @@ private:
    /// Points into fTeam to the column that successfully returned the last page.
    std::size_t fLastGoodTeamIdx = 0;
 
-   RColumn(EColumnType type, std::uint32_t columnIndex, std::uint16_t representationIndex);
+   RColumn(ENTupleColumnType type, std::uint32_t columnIndex, std::uint16_t representationIndex);
 
    /// Used when trying to append to a full write page. If possible, expand the page. Otherwise, flush and reset
    /// to the minimal size.
@@ -105,7 +105,8 @@ private:
 
 public:
    template <typename CppT>
-   static std::unique_ptr<RColumn> Create(EColumnType type, std::uint32_t columnIdx, std::uint16_t representationIdx)
+   static std::unique_ptr<RColumn>
+   Create(ENTupleColumnType type, std::uint32_t columnIdx, std::uint16_t representationIdx)
    {
       auto column = std::unique_ptr<RColumn>(new RColumn(type, columnIdx, representationIdx));
       column->fElement = RColumnElementBase::Generate<CppT>(type);
@@ -337,7 +338,7 @@ public:
 
    NTupleSize_t GetNElements() const { return fNElements; }
    RColumnElementBase *GetElement() const { return fElement.get(); }
-   EColumnType GetType() const { return fType; }
+   ENTupleColumnType GetType() const { return fType; }
    std::uint16_t GetBitsOnStorage() const
    {
       assert(fElement);

tree/ntuple/v7/inc/ROOT/RColumnElementBase.hxx

@@ -69,7 +69,7 @@ public:
    /// in-memory C++ type, given by a type index.
    struct RIdentifier {
       std::type_index fInMemoryType = std::type_index(typeid(void));
-      EColumnType fOnDiskType = EColumnType::kUnknown;
+      ENTupleColumnType fOnDiskType = ENTupleColumnType::kUnknown;
 
       bool operator==(const RIdentifier &other) const
       {
@@ -87,12 +87,12 @@ public:
 
    /// If CppT == void, use the default C++ type for the given column type
    template <typename CppT = void>
-   static std::unique_ptr<RColumnElementBase> Generate(EColumnType type);
-   static const char *GetColumnTypeName(EColumnType type);
+   static std::unique_ptr<RColumnElementBase> Generate(ENTupleColumnType type);
+   static const char *GetColumnTypeName(ENTupleColumnType type);
    /// Most types have a fixed on-disk bit width. Some low-precision column types
    /// have a range of possible bit widths. Return the minimum and maximum allowed
    /// bit size per type.
-   static std::pair<std::uint16_t, std::uint16_t> GetValidBitRange(EColumnType type);
+   static std::pair<std::uint16_t, std::uint16_t> GetValidBitRange(ENTupleColumnType type);
 
    /// Derived, typed classes tell whether the on-storage layout is bitwise identical to the memory layout
    virtual bool IsMappable() const
@@ -136,18 +136,18 @@ struct RTestFutureColumn {
    std::uint32_t dummy;
 };
 
-std::unique_ptr<RColumnElementBase> GenerateColumnElement(std::type_index inMemoryType, EColumnType onDiskType);
+std::unique_ptr<RColumnElementBase> GenerateColumnElement(std::type_index inMemoryType, ENTupleColumnType onDiskType);
 
 std::unique_ptr<RColumnElementBase> GenerateColumnElement(const RColumnElementBase::RIdentifier &elementId);
 
 template <typename CppT>
-std::unique_ptr<RColumnElementBase> RColumnElementBase::Generate(EColumnType onDiskType)
+std::unique_ptr<RColumnElementBase> RColumnElementBase::Generate(ENTupleColumnType onDiskType)
 {
    return GenerateColumnElement(std::type_index(typeid(CppT)), onDiskType);
 }
 
 template <>
-std::unique_ptr<RColumnElementBase> RColumnElementBase::Generate<void>(EColumnType onDiskType);
+std::unique_ptr<RColumnElementBase> RColumnElementBase::Generate<void>(ENTupleColumnType onDiskType);
 
 } // namespace ROOT::Experimental::Internal
 

tree/ntuple/v7/inc/ROOT/RField/RFieldFundamental.hxx

@@ -378,9 +378,9 @@ protected:
       fAvailableColumns.reserve(n);
       for (std::uint16_t i = 0; i < n; ++i) {
          auto &column = fAvailableColumns.emplace_back(Internal::RColumn::Create<T>(r[i][0], 0, i));
-         if (r[i][0] == EColumnType::kReal32Trunc) {
+         if (r[i][0] == ENTupleColumnType::kReal32Trunc) {
             column->SetBitsOnStorage(fBitWidth);
-         } else if (r[i][0] == EColumnType::kReal32Quant) {
+         } else if (r[i][0] == ENTupleColumnType::kReal32Quant) {
             column->SetBitsOnStorage(fBitWidth);
             column->SetValueRange(fValueMin, fValueMax);
          }
@@ -398,11 +398,11 @@ protected:
 
          auto &column =
             fAvailableColumns.emplace_back(Internal::RColumn::Create<T>(onDiskTypes[0], 0, representationIndex));
-         if (onDiskTypes[0] == EColumnType::kReal32Trunc) {
+         if (onDiskTypes[0] == ENTupleColumnType::kReal32Trunc) {
             const auto &fdesc = desc.GetFieldDescriptor(Base::GetOnDiskId());
             const auto &coldesc = desc.GetColumnDescriptor(fdesc.GetLogicalColumnIds()[0]);
             column->SetBitsOnStorage(coldesc.GetBitsOnStorage());
-         } else if (onDiskTypes[0] == EColumnType::kReal32Quant) {
+         } else if (onDiskTypes[0] == ENTupleColumnType::kReal32Quant) {
             const auto &fdesc = desc.GetFieldDescriptor(Base::GetOnDiskId());
             const auto &coldesc = desc.GetColumnDescriptor(fdesc.GetLogicalColumnIds()[0]);
             assert(coldesc.GetValueRange().has_value());
@@ -432,7 +432,7 @@ public:
    /// Sets this field to use a half precision representation, occupying half as much storage space (16 bits:
    /// 1 sign bit, 5 exponent bits, 10 mantissa bits) on disk.
    /// This is mutually exclusive with `SetTruncated` and `SetQuantized` and supersedes them if called after them.
-   void SetHalfPrecision() { SetColumnRepresentatives({{EColumnType::kReal16}}); }
+   void SetHalfPrecision() { SetColumnRepresentatives({{ENTupleColumnType::kReal16}}); }
 
    /// Set the on-disk representation of this field to a single-precision float truncated to `nBits`.
    /// The remaining (32 - `nBits`) bits will be truncated from the number's mantissa.
@@ -442,13 +442,13 @@ public:
    /// This is mutually exclusive with `SetHalfPrecision` and `SetQuantized` and supersedes them if called after them.
    void SetTruncated(std::size_t nBits)
    {
-      const auto &[minBits, maxBits] = Internal::RColumnElementBase::GetValidBitRange(EColumnType::kReal32Trunc);
+      const auto &[minBits, maxBits] = Internal::RColumnElementBase::GetValidBitRange(ENTupleColumnType::kReal32Trunc);
       if (nBits < minBits || nBits > maxBits) {
          throw RException(R__FAIL("SetTruncated() argument nBits = " + std::to_string(nBits) +
                                   " is out of valid range [" + std::to_string(minBits) + ", " +
                                   std::to_string(maxBits) + "])"));
       }
-      SetColumnRepresentatives({{EColumnType::kReal32Trunc}});
+      SetColumnRepresentatives({{ENTupleColumnType::kReal32Trunc}});
       fBitWidth = nBits;
    }
 
@@ -462,13 +462,13 @@ public:
    /// This is mutually exclusive with `SetTruncated` and `SetHalfPrecision` and supersedes them if called after them.
    void SetQuantized(double minValue, double maxValue, std::size_t nBits)
    {
-      const auto &[minBits, maxBits] = Internal::RColumnElementBase::GetValidBitRange(EColumnType::kReal32Quant);
+      const auto &[minBits, maxBits] = Internal::RColumnElementBase::GetValidBitRange(ENTupleColumnType::kReal32Quant);
       if (nBits < minBits || nBits > maxBits) {
          throw RException(R__FAIL("SetQuantized() argument nBits = " + std::to_string(nBits) +
                                   " is out of valid range [" + std::to_string(minBits) + ", " +
                                   std::to_string(maxBits) + "])"));
       }
-      SetColumnRepresentatives({{EColumnType::kReal32Quant}});
+      SetColumnRepresentatives({{ENTupleColumnType::kReal32Quant}});
       fBitWidth = nBits;
       fValueMin = minValue;
       fValueMax = maxValue;

tree/ntuple/v7/inc/ROOT/RFieldBase.hxx

@@ -127,7 +127,7 @@ public:
    /// Shorthand for types that are both trivially constructible and destructible
    static constexpr int kTraitTrivialType = kTraitTriviallyConstructible | kTraitTriviallyDestructible;
 
-   using ColumnRepresentation_t = std::vector<EColumnType>;
+   using ColumnRepresentation_t = std::vector<ENTupleColumnType>;
 
    /// During its lifetime, a field undergoes the following possible state transitions:
    ///

tree/ntuple/v7/inc/ROOT/RNTupleDescriptor.hxx

@@ -185,7 +185,7 @@ private:
    /// but low-precision float columns have variable bit widths.
    std::uint16_t fBitsOnStorage = 0;
    /// The on-disk column type
-   EColumnType fType = EColumnType::kUnknown;
+   ENTupleColumnType fType = ENTupleColumnType::kUnknown;
    /// Optional value range (used e.g. by quantized real fields)
    std::optional<RValueRange> fValueRange;
 
@@ -207,7 +207,7 @@ public:
    std::uint16_t GetRepresentationIndex() const { return fRepresentationIndex; }
    std::uint64_t GetFirstElementIndex() const { return std::abs(fFirstElementIndex); }
    std::uint16_t GetBitsOnStorage() const { return fBitsOnStorage; }
-   EColumnType GetType() const { return fType; }
+   ENTupleColumnType GetType() const { return fType; }
    std::optional<RValueRange> GetValueRange() const { return fValueRange; }
    bool IsAliasColumn() const { return fPhysicalColumnId != fLogicalColumnId; }
    bool IsDeferredColumn() const { return fFirstElementIndex != 0; }
@@ -1062,7 +1062,7 @@ public:
       fColumn.fBitsOnStorage = bitsOnStorage;
       return *this;
    }
-   RColumnDescriptorBuilder &Type(EColumnType type)
+   RColumnDescriptorBuilder &Type(ENTupleColumnType type)
    {
       fColumn.fType = type;
       return *this;

tree/ntuple/v7/inc/ROOT/RNTupleSerialize.hxx

@@ -35,7 +35,7 @@ class TVirtualStreamerInfo;
 namespace ROOT {
 namespace Experimental {
 
-enum class EColumnType;
+enum class ENTupleColumnType;
 enum class EExtraTypeInfoIds;
 class RClusterDescriptor;
 class RNTupleDescriptor;
@@ -214,11 +214,11 @@ public:
    /// While we could just interpret the enums as ints, we make the translation explicit
    /// in order to avoid accidentally changing the on-disk numbers when adjusting the enum classes.
    static std::uint32_t SerializeFieldStructure(ROOT::Experimental::ENTupleStructure structure, void *buffer);
-   static std::uint32_t SerializeColumnType(ROOT::Experimental::EColumnType type, void *buffer);
+   static std::uint32_t SerializeColumnType(ROOT::Experimental::ENTupleColumnType type, void *buffer);
    static std::uint32_t SerializeExtraTypeInfoId(ROOT::Experimental::EExtraTypeInfoIds id, void *buffer);
    static RResult<std::uint32_t>
    DeserializeFieldStructure(const void *buffer, ROOT::Experimental::ENTupleStructure &structure);
-   static RResult<std::uint32_t> DeserializeColumnType(const void *buffer, ROOT::Experimental::EColumnType &type);
+   static RResult<std::uint32_t> DeserializeColumnType(const void *buffer, ROOT::Experimental::ENTupleColumnType &type);
    static RResult<std::uint32_t>
    DeserializeExtraTypeInfoId(const void *buffer, ROOT::Experimental::EExtraTypeInfoIds &id);
 

tree/ntuple/v7/inc/ROOT/RNTupleUtil.hxx

@@ -57,7 +57,7 @@ ROOT::RLogChannel &NTupleLog();
 
 // clang-format off
 /**
-\class ROOT::Experimental::EColumnType
+\class ROOT::Experimental::ENTupleColumnType
 \ingroup NTuple
 \brief The available trivial, native content types of a column
 
@@ -71,7 +71,7 @@ When changed, remember to update
   - RNTupleSerializer::[Des|S]erializeColumnType
 */
 // clang-format on
-enum class EColumnType {
+enum class ENTupleColumnType {
    kUnknown = 0,
    // type for root columns of (nested) collections; offsets are relative to the current cluster
    kIndex64,
@@ -299,8 +299,8 @@ std::unique_ptr<T[]> MakeUninitArray(std::size_t size)
    return std::unique_ptr<T[]>(new T[size]);
 }
 
-inline constexpr EColumnType kTestFutureType =
-   static_cast<EColumnType>(std::numeric_limits<std::underlying_type_t<EColumnType>>::max() - 1);
+inline constexpr ENTupleColumnType kTestFutureType =
+   static_cast<ENTupleColumnType>(std::numeric_limits<std::underlying_type_t<ENTupleColumnType>>::max() - 1);
 
 inline constexpr ENTupleStructure kTestFutureFieldStructure =
    static_cast<ENTupleStructure>(std::numeric_limits<std::underlying_type_t<ENTupleStructure>>::max() - 1);

tree/ntuple/v7/src/RColumn.cxx

@@ -23,7 +23,7 @@
 #include <cassert>
 #include <utility>
 
-ROOT::Experimental::Internal::RColumn::RColumn(EColumnType type, std::uint32_t columnIndex,
+ROOT::Experimental::Internal::RColumn::RColumn(ENTupleColumnType type, std::uint32_t columnIndex,
                                                std::uint16_t representationIndex)
    : fType(type), fIndex(columnIndex), fRepresentationIndex(representationIndex), fTeam({this})
 {