From 22ccc2aabf596733b9a705a2c5ce3436c914c7d8 Mon Sep 17 00:00:00 2001
From: Florine de Geus <florine.de.geus@cern.ch>
Date: Fri, 28 Feb 2025 15:33:35 +0100
Subject: [PATCH 1/2] Fix `EColumnType` deprecation warning

---
 types/fundamental/integer/write.C | 42 +++++++++++++++----------------
 types/fundamental/misc/write.C    | 11 ++++----
 types/fundamental/real/write.C    | 24 +++++++++---------
 types/string/write.C              | 20 ++++++++-------
 types/vector/fundamental/write.C  | 14 ++++++-----
 types/vector/nested/write.C       | 14 ++++++-----
 6 files changed, 66 insertions(+), 59 deletions(-)

diff --git a/types/fundamental/integer/write.C b/types/fundamental/integer/write.C
index ebd3100..404efe4 100644
--- a/types/fundamental/integer/write.C
+++ b/types/fundamental/integer/write.C
@@ -4,7 +4,7 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
-using ROOT::Experimental::EColumnType;
+using ROOT::ENTupleColumnType;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
 using ROOT::Experimental::RNTupleWriteOptions;
@@ -18,7 +18,7 @@ using ROOT::Experimental::RNTupleWriter;
 template <typename T>
 static std::shared_ptr<T> MakeFundamentalField(RNTupleModel &model,
                                                std::string_view name,
-                                               EColumnType type) {
+                                               ENTupleColumnType type) {
   auto field = std::make_unique<RField<T>>(name);
   field->SetColumnRepresentatives({{type}});
   model.AddField(std::move(field));
@@ -28,38 +28,38 @@ static std::shared_ptr<T> MakeFundamentalField(RNTupleModel &model,
 void write(std::string_view filename = "types.fundamental.integer.root") {
   auto model = RNTupleModel::Create();
 
-  auto Int8 =
-      MakeFundamentalField<std::int8_t>(*model, "Int8", EColumnType::kInt8);
-  auto UInt8 =
-      MakeFundamentalField<std::uint8_t>(*model, "UInt8", EColumnType::kUInt8);
+  auto Int8 = MakeFundamentalField<std::int8_t>(*model, "Int8",
+                                                ENTupleColumnType::kInt8);
+  auto UInt8 = MakeFundamentalField<std::uint8_t>(*model, "UInt8",
+                                                  ENTupleColumnType::kUInt8);
 
   // Non-split integer encoding
-  auto Int16 =
-      MakeFundamentalField<std::int16_t>(*model, "Int16", EColumnType::kInt16);
+  auto Int16 = MakeFundamentalField<std::int16_t>(*model, "Int16",
+                                                  ENTupleColumnType::kInt16);
   auto UInt16 = MakeFundamentalField<std::uint16_t>(*model, "UInt16",
-                                                    EColumnType::kUInt16);
-  auto Int32 =
-      MakeFundamentalField<std::int32_t>(*model, "Int32", EColumnType::kInt32);
+                                                    ENTupleColumnType::kUInt16);
+  auto Int32 = MakeFundamentalField<std::int32_t>(*model, "Int32",
+                                                  ENTupleColumnType::kInt32);
   auto UInt32 = MakeFundamentalField<std::uint32_t>(*model, "UInt32",
-                                                    EColumnType::kUInt32);
-  auto Int64 =
-      MakeFundamentalField<std::int64_t>(*model, "Int64", EColumnType::kInt64);
+                                                    ENTupleColumnType::kUInt32);
+  auto Int64 = MakeFundamentalField<std::int64_t>(*model, "Int64",
+                                                  ENTupleColumnType::kInt64);
   auto UInt64 = MakeFundamentalField<std::uint64_t>(*model, "UInt64",
-                                                    EColumnType::kUInt64);
+                                                    ENTupleColumnType::kUInt64);
 
   // Split integer encoding
   auto SplitInt16 = MakeFundamentalField<std::int16_t>(
-      *model, "SplitInt16", EColumnType::kSplitInt16);
+      *model, "SplitInt16", ENTupleColumnType::kSplitInt16);
   auto SplitUInt16 = MakeFundamentalField<std::uint16_t>(
-      *model, "SplitUInt16", EColumnType::kSplitUInt16);
+      *model, "SplitUInt16", ENTupleColumnType::kSplitUInt16);
   auto SplitInt32 = MakeFundamentalField<std::int32_t>(
-      *model, "SplitInt32", EColumnType::kSplitInt32);
+      *model, "SplitInt32", ENTupleColumnType::kSplitInt32);
   auto SplitUInt32 = MakeFundamentalField<std::uint32_t>(
-      *model, "SplitUInt32", EColumnType::kSplitUInt32);
+      *model, "SplitUInt32", ENTupleColumnType::kSplitUInt32);
   auto SplitInt64 = MakeFundamentalField<std::int64_t>(
-      *model, "SplitInt64", EColumnType::kSplitInt64);
+      *model, "SplitInt64", ENTupleColumnType::kSplitInt64);
   auto SplitUInt64 = MakeFundamentalField<std::uint64_t>(
-      *model, "SplitUInt64", EColumnType::kSplitUInt64);
+      *model, "SplitUInt64", ENTupleColumnType::kSplitUInt64);
 
   RNTupleWriteOptions options;
   options.SetCompression(0);
diff --git a/types/fundamental/misc/write.C b/types/fundamental/misc/write.C
index 45450c5..3f9e5f6 100644
--- a/types/fundamental/misc/write.C
+++ b/types/fundamental/misc/write.C
@@ -4,7 +4,7 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
-using ROOT::Experimental::EColumnType;
+using ROOT::ENTupleColumnType;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
 using ROOT::Experimental::RNTupleWriteOptions;
@@ -18,7 +18,7 @@ using ROOT::Experimental::RNTupleWriter;
 template <typename T>
 static std::shared_ptr<T> MakeFundamentalField(RNTupleModel &model,
                                                std::string_view name,
-                                               EColumnType type) {
+                                               ENTupleColumnType type) {
   auto field = std::make_unique<RField<T>>(name);
   field->SetColumnRepresentatives({{type}});
   model.AddField(std::move(field));
@@ -28,10 +28,11 @@ static std::shared_ptr<T> MakeFundamentalField(RNTupleModel &model,
 void write(std::string_view filename = "types.fundamental.misc.root") {
   auto model = RNTupleModel::Create();
 
-  auto Bit = MakeFundamentalField<bool>(*model, "Bit", EColumnType::kBit);
+  auto Bit = MakeFundamentalField<bool>(*model, "Bit", ENTupleColumnType::kBit);
   auto Byte =
-      MakeFundamentalField<std::byte>(*model, "Byte", EColumnType::kByte);
-  auto Char = MakeFundamentalField<char>(*model, "Char", EColumnType::kChar);
+      MakeFundamentalField<std::byte>(*model, "Byte", ENTupleColumnType::kByte);
+  auto Char =
+      MakeFundamentalField<char>(*model, "Char", ENTupleColumnType::kChar);
 
   RNTupleWriteOptions options;
   options.SetCompression(0);
diff --git a/types/fundamental/real/write.C b/types/fundamental/real/write.C
index 33e0728..ab95826 100644
--- a/types/fundamental/real/write.C
+++ b/types/fundamental/real/write.C
@@ -4,7 +4,7 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
-using ROOT::Experimental::EColumnType;
+using ROOT::ENTupleColumnType;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
 using ROOT::Experimental::RNTupleWriteOptions;
@@ -17,7 +17,7 @@ using ROOT::Experimental::RNTupleWriter;
 template <typename T>
 static std::shared_ptr<T> MakeFundamentalField(RNTupleModel &model,
                                                std::string_view name,
-                                               EColumnType type) {
+                                               ENTupleColumnType type) {
   auto field = std::make_unique<RField<T>>(name);
   field->SetColumnRepresentatives({{type}});
   model.AddField(std::move(field));
@@ -28,25 +28,25 @@ void write(std::string_view filename = "types.fundamental.real.root") {
   auto model = RNTupleModel::Create();
 
   // Non-split float encoding
-  auto FloatReal16 =
-      MakeFundamentalField<float>(*model, "FloatReal16", EColumnType::kReal16);
-  auto FloatReal32 =
-      MakeFundamentalField<float>(*model, "FloatReal32", EColumnType::kReal32);
+  auto FloatReal16 = MakeFundamentalField<float>(*model, "FloatReal16",
+                                                 ENTupleColumnType::kReal16);
+  auto FloatReal32 = MakeFundamentalField<float>(*model, "FloatReal32",
+                                                 ENTupleColumnType::kReal32);
   auto DoubleReal16 = MakeFundamentalField<double>(*model, "DoubleReal16",
-                                                   EColumnType::kReal16);
+                                                   ENTupleColumnType::kReal16);
   auto DoubleReal32 = MakeFundamentalField<double>(*model, "DoubleReal32",
-                                                   EColumnType::kReal32);
+                                                   ENTupleColumnType::kReal32);
   auto DoubleReal64 = MakeFundamentalField<double>(*model, "DoubleReal64",
-                                                   EColumnType::kReal64);
+                                                   ENTupleColumnType::kReal64);
 
   // Split float encoding
   // NB there is no kSplitReal16
   auto FloatSplitReal32 = MakeFundamentalField<float>(
-      *model, "FloatSplitReal32", EColumnType::kSplitReal32);
+      *model, "FloatSplitReal32", ENTupleColumnType::kSplitReal32);
   auto DoubleSplitReal32 = MakeFundamentalField<double>(
-      *model, "DoubleSplitReal32", EColumnType::kSplitReal32);
+      *model, "DoubleSplitReal32", ENTupleColumnType::kSplitReal32);
   auto DoubleSplitReal64 = MakeFundamentalField<double>(
-      *model, "DoubleSplitReal64", EColumnType::kSplitReal64);
+      *model, "DoubleSplitReal64", ENTupleColumnType::kSplitReal64);
 
   RNTupleWriteOptions options;
   options.SetCompression(0);
diff --git a/types/string/write.C b/types/string/write.C
index bbdd3ea..7d11b58 100644
--- a/types/string/write.C
+++ b/types/string/write.C
@@ -4,7 +4,7 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
-using ROOT::Experimental::EColumnType;
+using ROOT::ENTupleColumnType;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
 using ROOT::Experimental::RNTupleWriteOptions;
@@ -14,11 +14,11 @@ using ROOT::Experimental::RNTupleWriter;
 #include <string>
 #include <string_view>
 
-static std::shared_ptr<std::string> MakeStringField(RNTupleModel &model,
-                                                    std::string_view name,
-                                                    EColumnType indexType) {
+static std::shared_ptr<std::string>
+MakeStringField(RNTupleModel &model, std::string_view name,
+                ENTupleColumnType indexType) {
   auto field = std::make_unique<RField<std::string>>(name);
-  field->SetColumnRepresentatives({{indexType, EColumnType::kChar}});
+  field->SetColumnRepresentatives({{indexType, ENTupleColumnType::kChar}});
   model.AddField(std::move(field));
   return model.GetDefaultEntry().GetPtr<std::string>(name);
 }
@@ -27,14 +27,16 @@ void write(std::string_view filename = "types.string.root") {
   auto model = RNTupleModel::Create();
 
   // Non-split index encoding
-  auto Index32 = MakeStringField(*model, "Index32", EColumnType::kIndex32);
-  auto Index64 = MakeStringField(*model, "Index64", EColumnType::kIndex64);
+  auto Index32 =
+      MakeStringField(*model, "Index32", ENTupleColumnType::kIndex32);
+  auto Index64 =
+      MakeStringField(*model, "Index64", ENTupleColumnType::kIndex64);
 
   // Split index encoding
   auto SplitIndex32 =
-      MakeStringField(*model, "SplitIndex32", EColumnType::kSplitIndex32);
+      MakeStringField(*model, "SplitIndex32", ENTupleColumnType::kSplitIndex32);
   auto SplitIndex64 =
-      MakeStringField(*model, "SplitIndex64", EColumnType::kSplitIndex64);
+      MakeStringField(*model, "SplitIndex64", ENTupleColumnType::kSplitIndex64);
 
   RNTupleWriteOptions options;
   options.SetCompression(0);
diff --git a/types/vector/fundamental/write.C b/types/vector/fundamental/write.C
index f8a2c2a..abd0908 100644
--- a/types/vector/fundamental/write.C
+++ b/types/vector/fundamental/write.C
@@ -4,7 +4,7 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
-using ROOT::Experimental::EColumnType;
+using ROOT::ENTupleColumnType;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
 using ROOT::Experimental::RNTupleWriteOptions;
@@ -19,7 +19,7 @@ using Vector = std::vector<std::int32_t>;
 
 static std::shared_ptr<Vector> MakeVectorField(RNTupleModel &model,
                                                std::string_view name,
-                                               EColumnType indexType) {
+                                               ENTupleColumnType indexType) {
   auto field = std::make_unique<RField<Vector>>(name);
   field->SetColumnRepresentatives({{indexType}});
   model.AddField(std::move(field));
@@ -30,14 +30,16 @@ void write(std::string_view filename = "types.vector.fundamental.root") {
   auto model = RNTupleModel::Create();
 
   // Non-split index encoding
-  auto Index32 = MakeVectorField(*model, "Index32", EColumnType::kIndex32);
-  auto Index64 = MakeVectorField(*model, "Index64", EColumnType::kIndex64);
+  auto Index32 =
+      MakeVectorField(*model, "Index32", ENTupleColumnType::kIndex32);
+  auto Index64 =
+      MakeVectorField(*model, "Index64", ENTupleColumnType::kIndex64);
 
   // Split index encoding
   auto SplitIndex32 =
-      MakeVectorField(*model, "SplitIndex32", EColumnType::kSplitIndex32);
+      MakeVectorField(*model, "SplitIndex32", ENTupleColumnType::kSplitIndex32);
   auto SplitIndex64 =
-      MakeVectorField(*model, "SplitIndex64", EColumnType::kSplitIndex64);
+      MakeVectorField(*model, "SplitIndex64", ENTupleColumnType::kSplitIndex64);
 
   RNTupleWriteOptions options;
   options.SetCompression(0);
diff --git a/types/vector/nested/write.C b/types/vector/nested/write.C
index a83d2ea..ca47fb2 100644
--- a/types/vector/nested/write.C
+++ b/types/vector/nested/write.C
@@ -4,7 +4,7 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
-using ROOT::Experimental::EColumnType;
+using ROOT::ENTupleColumnType;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
 using ROOT::Experimental::RNTupleWriteOptions;
@@ -19,7 +19,7 @@ using Vector = std::vector<std::vector<std::int32_t>>;
 
 static std::shared_ptr<Vector> MakeVectorField(RNTupleModel &model,
                                                std::string_view name,
-                                               EColumnType indexType) {
+                                               ENTupleColumnType indexType) {
   auto field = std::make_unique<RField<Vector>>(name);
   field->SetColumnRepresentatives({{indexType}});
   field->GetSubFields()[0]->SetColumnRepresentatives({{indexType}});
@@ -31,14 +31,16 @@ void write(std::string_view filename = "types.vector.nested.root") {
   auto model = RNTupleModel::Create();
 
   // Non-split index encoding
-  auto Index32 = MakeVectorField(*model, "Index32", EColumnType::kIndex32);
-  auto Index64 = MakeVectorField(*model, "Index64", EColumnType::kIndex64);
+  auto Index32 =
+      MakeVectorField(*model, "Index32", ENTupleColumnType::kIndex32);
+  auto Index64 =
+      MakeVectorField(*model, "Index64", ENTupleColumnType::kIndex64);
 
   // Split index encoding
   auto SplitIndex32 =
-      MakeVectorField(*model, "SplitIndex32", EColumnType::kSplitIndex32);
+      MakeVectorField(*model, "SplitIndex32", ENTupleColumnType::kSplitIndex32);
   auto SplitIndex64 =
-      MakeVectorField(*model, "SplitIndex64", EColumnType::kSplitIndex64);
+      MakeVectorField(*model, "SplitIndex64", ENTupleColumnType::kSplitIndex64);
 
   RNTupleWriteOptions options;
   options.SetCompression(0);

From 7b05d3eeef84b701d70b6cd9175bec2d69d2222c Mon Sep 17 00:00:00 2001
From: Florine de Geus <florine.de.geus@cern.ch>
Date: Fri, 28 Feb 2025 15:35:26 +0100
Subject: [PATCH 2/2] Fix `RNTupleWriteOptions` deprecation warning

---
 types/fundamental/integer/write.C | 2 +-
 types/fundamental/misc/write.C    | 2 +-
 types/fundamental/real/write.C    | 2 +-
 types/string/write.C              | 2 +-
 types/variant/write.C             | 2 +-
 types/vector/fundamental/write.C  | 2 +-
 types/vector/nested/write.C       | 2 +-
 7 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/types/fundamental/integer/write.C b/types/fundamental/integer/write.C
index 404efe4..4c91a38 100644
--- a/types/fundamental/integer/write.C
+++ b/types/fundamental/integer/write.C
@@ -5,9 +5,9 @@
 #include <ROOT/RNTupleWriter.hxx>
 
 using ROOT::ENTupleColumnType;
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <cstdint>
diff --git a/types/fundamental/misc/write.C b/types/fundamental/misc/write.C
index 3f9e5f6..4f03b7f 100644
--- a/types/fundamental/misc/write.C
+++ b/types/fundamental/misc/write.C
@@ -5,9 +5,9 @@
 #include <ROOT/RNTupleWriter.hxx>
 
 using ROOT::ENTupleColumnType;
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <cstddef> // for std::byte
diff --git a/types/fundamental/real/write.C b/types/fundamental/real/write.C
index ab95826..be60a29 100644
--- a/types/fundamental/real/write.C
+++ b/types/fundamental/real/write.C
@@ -5,9 +5,9 @@
 #include <ROOT/RNTupleWriter.hxx>
 
 using ROOT::ENTupleColumnType;
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <limits>
diff --git a/types/string/write.C b/types/string/write.C
index 7d11b58..479cbec 100644
--- a/types/string/write.C
+++ b/types/string/write.C
@@ -5,9 +5,9 @@
 #include <ROOT/RNTupleWriter.hxx>
 
 using ROOT::ENTupleColumnType;
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <memory>
diff --git a/types/variant/write.C b/types/variant/write.C
index 5bdee4d..f997910 100644
--- a/types/variant/write.C
+++ b/types/variant/write.C
@@ -2,8 +2,8 @@
 #include <ROOT/RNTupleWriteOptions.hxx>
 #include <ROOT/RNTupleWriter.hxx>
 
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <cstdint>
diff --git a/types/vector/fundamental/write.C b/types/vector/fundamental/write.C
index abd0908..e2d38e5 100644
--- a/types/vector/fundamental/write.C
+++ b/types/vector/fundamental/write.C
@@ -5,9 +5,9 @@
 #include <ROOT/RNTupleWriter.hxx>
 
 using ROOT::ENTupleColumnType;
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <cstdint>
diff --git a/types/vector/nested/write.C b/types/vector/nested/write.C
index ca47fb2..3120ff8 100644
--- a/types/vector/nested/write.C
+++ b/types/vector/nested/write.C
@@ -5,9 +5,9 @@
 #include <ROOT/RNTupleWriter.hxx>
 
 using ROOT::ENTupleColumnType;
+using ROOT::RNTupleWriteOptions;
 using ROOT::Experimental::RField;
 using ROOT::Experimental::RNTupleModel;
-using ROOT::Experimental::RNTupleWriteOptions;
 using ROOT::Experimental::RNTupleWriter;
 
 #include <cstdint>