Add test for user-defined enums

Closes #12

Author: hahnjo

types/user/README.md

@@ -1,3 +1,4 @@
 # User-defined Types
 
  * [`class`]: user-defined class(es)
+ * [`enum`]: user-defined enum(s)

types/user/enum/LinkDef.h

@@ -0,0 +1,10 @@
+#ifdef __CLING__
+#pragma link C++ enum EnumInt8+;
+#pragma link C++ enum EnumUInt8+;
+#pragma link C++ enum EnumInt16+;
+#pragma link C++ enum EnumUInt16+;
+#pragma link C++ enum EnumInt32+;
+#pragma link C++ enum EnumUInt32+;
+#pragma link C++ enum EnumInt64+;
+#pragma link C++ enum EnumUInt64+;
+#endif

types/user/enum/Makefile

@@ -0,0 +1,20 @@
+CXX=g++
+CXXFLAGS_ROOT=$(shell root-config --cflags)
+ifeq ($(CXXFLAGS_ROOT),)
+  $(error cannot find root-config: make sure to source thisroot.sh)
+endif
+CXXFLAGS=-Wall $(CXXFLAGS_ROOT)
+LDFLAGS=$(shell root-config --libs)
+
+.PHONY: all clean
+
+all: UserEnum.cxx libUserEnum.so
+
+UserEnum.cxx: UserEnum.hxx LinkDef.h
+	rootcling -f $@ $^
+
+libUserEnum.so: UserEnum.cxx
+	$(CXX) -shared -fPIC -o $@ $^ $(CXXFLAGS) $(LDFLAGS)
+
+clean:
+	rm -f UserEnum.cxx UserEnum_rdict.pcm libUserEnum.so

types/user/enum/README.md

@@ -0,0 +1,12 @@
+# User-defined enum(s)
+
+## Fields
+
+ * `Enum[U]Int{8,16,32,64}`
+
+with the default column types.
+
+## Entries
+
+1. Simple values
+2. Zero values

types/user/enum/UserEnum.hxx

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <cstdint>
+
+enum class EnumInt8 : std::int8_t {
+  Zero = 0,
+  Simple = 1,
+};
+
+enum class EnumUInt8 : std::uint8_t {
+  Zero = 0,
+  Simple = 2,
+};
+
+enum class EnumInt16 : std::int16_t {
+  Zero = 0,
+  Simple = 3,
+};
+
+enum class EnumUInt16 : std::uint16_t {
+  Zero = 0,
+  Simple = 4,
+};
+
+enum class EnumInt32 : std::int32_t {
+  Zero = 0,
+  Simple = 5,
+};
+
+enum class EnumUInt32 : std::uint32_t {
+  Zero = 0,
+  Simple = 6,
+};
+
+enum class EnumInt64 : std::int64_t {
+  Zero = 0,
+  Simple = 7,
+};
+
+enum class EnumUInt64 : std::uint64_t {
+  Zero = 0,
+  Simple = 8,
+};

types/user/enum/read.C

@@ -0,0 +1,67 @@
+#include <ROOT/REntry.hxx>
+#include <ROOT/RNTupleReader.hxx>
+
+using ROOT::Experimental::REntry;
+using ROOT::Experimental::RNTupleReader;
+
+#include <cstdint>
+#include <fstream>
+#include <ostream>
+#include <string>
+#include <string_view>
+#include <type_traits>
+
+#include "UserEnum.hxx"
+
+template <typename T>
+static void PrintEnumValue(const REntry &entry, std::string_view name,
+                           std::ostream &os, bool last = false) {
+  T value = *entry.GetPtr<T>(name);
+  os << "    \"" << name << "\": ";
+  // We want to print the integer value even if it is a character; use the unary
+  // + operator (https://stackoverflow.com/a/28414758).
+  os << +static_cast<std::underlying_type_t<T>>(value);
+  if (!last) {
+    os << ",";
+  }
+  os << "\n";
+}
+
+void read(std::string_view input = "types.user.enum.root",
+          std::string_view output = "types.user.enum.json") {
+  if (gSystem->Load("libUserEnum") == -1)
+    throw std::runtime_error("could not find the required ROOT dictionaries, "
+                             "please make sure to run `make` first");
+
+  std::ofstream os(std::string{output});
+  os << "[\n";
+
+  auto reader = RNTupleReader::Open("ntpl", input);
+  auto &entry = reader->GetModel().GetDefaultEntry();
+  bool first = true;
+  for (auto index : *reader) {
+    reader->LoadEntry(index);
+
+    if (first) {
+      first = false;
+    } else {
+      os << ",\n";
+    }
+    os << "  {\n";
+
+    PrintEnumValue<EnumInt8>(entry, "EnumInt8", os);
+    PrintEnumValue<EnumUInt8>(entry, "EnumUInt8", os);
+    PrintEnumValue<EnumInt16>(entry, "EnumInt16", os);
+    PrintEnumValue<EnumUInt16>(entry, "EnumUInt16", os);
+    PrintEnumValue<EnumInt32>(entry, "EnumInt32", os);
+    PrintEnumValue<EnumUInt32>(entry, "EnumUInt32", os);
+    PrintEnumValue<EnumInt64>(entry, "EnumInt64", os);
+    PrintEnumValue<EnumUInt64>(entry, "EnumUInt64", os, /*last=*/true);
+
+    os << "  }";
+    // Newline is intentionally missing, may need to print a comma before the
+    // next entry.
+  }
+  os << "\n";
+  os << "]\n";
+}

types/user/enum/write.C

@@ -0,0 +1,58 @@
+#include <ROOT/RNTupleModel.hxx>
+#include <ROOT/RNTupleWriteOptions.hxx>
+#include <ROOT/RNTupleWriter.hxx>
+
+using ROOT::Experimental::RNTupleModel;
+using ROOT::Experimental::RNTupleWriteOptions;
+using ROOT::Experimental::RNTupleWriter;
+
+#include <TSystem.h>
+
+#include <string_view>
+
+#include "UserEnum.hxx"
+
+void write(std::string_view filename = "types.user.enum.root") {
+  if (gSystem->Load("libUserEnum") == -1)
+    throw std::runtime_error("could not find the required ROOT dictionaries, "
+                             "please make sure to run `make` first");
+
+  auto model = RNTupleModel::Create();
+
+  // TODO: enums with bool underlying type are possible since ROOT 6.38
+  auto EInt8 = model->MakeField<EnumInt8>("EnumInt8");
+  auto EUInt8 = model->MakeField<EnumUInt8>("EnumUInt8");
+  auto EInt16 = model->MakeField<EnumInt16>("EnumInt16");
+  auto EUInt16 = model->MakeField<EnumUInt16>("EnumUInt16");
+  auto EInt32 = model->MakeField<EnumInt32>("EnumInt32");
+  auto EUInt32 = model->MakeField<EnumUInt32>("EnumUInt32");
+  auto EInt64 = model->MakeField<EnumInt64>("EnumInt64");
+  auto EUInt64 = model->MakeField<EnumUInt64>("EnumUInt64");
+
+  RNTupleWriteOptions options;
+  options.SetCompression(0);
+  auto writer =
+      RNTupleWriter::Recreate(std::move(model), "ntpl", filename, options);
+
+  // First entry: simple values
+  *EInt8 = EnumInt8::Simple;     // = 1;
+  *EUInt8 = EnumUInt8::Simple;   // = 2;
+  *EInt16 = EnumInt16::Simple;   // = 3;
+  *EUInt16 = EnumUInt16::Simple; // = 4;
+  *EInt32 = EnumInt32::Simple;   // = 5;
+  *EUInt32 = EnumUInt32::Simple; // = 6;
+  *EInt64 = EnumInt64::Simple;   // = 7;
+  *EUInt64 = EnumUInt64::Simple; // = 8;
+  writer->Fill();
+
+  // Second entry: zero values
+  *EInt8 = EnumInt8::Zero;
+  *EUInt8 = EnumUInt8::Zero;
+  *EInt16 = EnumInt16::Zero;
+  *EUInt16 = EnumUInt16::Zero;
+  *EInt32 = EnumInt32::Zero;
+  *EUInt32 = EnumUInt32::Zero;
+  *EInt64 = EnumInt64::Zero;
+  *EUInt64 = EnumUInt64::Zero;
+  writer->Fill();
+}