Add test for std::atomic

Closes #8

Author: hahnjo

types/README.md

@@ -1,6 +1,7 @@
 # Types
 
  * [`array`](array): `std::array`
+ * [`atomic`](atomic): `std::atomic`
  * [`fundamental`](fundamental): fundamental column types
  * [`multiset`](multiset): `std::multiset` with all `[Split]Index{32,64}` column types
  * [`optional`](optional): `std::optional` with different element types

types/atomic/README.md

@@ -0,0 +1,16 @@
+# `std::atomic`
+
+## Fields
+
+ * `Bit`
+ * `Byte`
+ * `Char`
+ * `[U]Int{8,16,32,64}`
+ * `Real{32,64}`
+
+with the corresponding column types.
+
+## Entries
+
+1. Ascending values
+2. Zero values

types/atomic/read.C

@@ -0,0 +1,82 @@
+#include <ROOT/REntry.hxx>
+#include <ROOT/RNTupleReader.hxx>
+
+using ROOT::Experimental::REntry;
+using ROOT::Experimental::RNTupleReader;
+
+#include <atomic>
+#include <cstddef> // for std::byte
+#include <cstdint>
+#include <fstream>
+#include <ostream>
+#include <string>
+#include <string_view>
+
+template <typename T>
+static void PrintIntegerValue(const REntry &entry, std::string_view name,
+                              std::ostream &os, bool last = false) {
+  T value = *entry.GetPtr<std::atomic<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 << +value;
+  if (!last) {
+    os << ",";
+  }
+  os << "\n";
+}
+
+template <typename T>
+static void PrintRealValue(const REntry &entry, std::string_view name,
+                           std::ostream &os, bool last = false) {
+  T value = *entry.GetPtr<std::atomic<T>>(name);
+  os << "    \"" << name << "\": \"" << value << "\"";
+  if (!last) {
+    os << ",";
+  }
+  os << "\n";
+}
+
+void read(std::string_view input = "types.atomic.root",
+          std::string_view output = "types.atomic.json") {
+  std::ofstream os(std::string{output});
+  // Print floating-point numbers as hexadecimal literals.
+  os << std::hexfloat;
+  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";
+
+    PrintIntegerValue<bool>(entry, "Bit", os);
+    os << "    \"Byte\": ";
+    os << std::to_integer<int>(*entry.GetPtr<std::atomic<std::byte>>("Byte"));
+    os << ",\n";
+    PrintIntegerValue<char>(entry, "Char", os);
+    PrintIntegerValue<std::int8_t>(entry, "Int8", os);
+    PrintIntegerValue<std::uint8_t>(entry, "UInt8", os);
+    PrintIntegerValue<std::int16_t>(entry, "Int16", os);
+    PrintIntegerValue<std::uint16_t>(entry, "UInt16", os);
+    PrintIntegerValue<std::int32_t>(entry, "Int32", os);
+    PrintIntegerValue<std::uint32_t>(entry, "UInt32", os);
+    PrintIntegerValue<std::int64_t>(entry, "Int64", os);
+    PrintIntegerValue<std::uint64_t>(entry, "UInt64", os);
+    PrintRealValue<float>(entry, "Real32", os);
+    PrintRealValue<double>(entry, "Real64", os, /*last=*/true);
+
+    os << "  }";
+    // Newline is intentionally missing, may need to print a comma before the
+    // next entry.
+  }
+  os << "\n";
+  os << "]\n";
+}

types/atomic/write.C

@@ -0,0 +1,76 @@
+#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 <atomic>
+#include <cstddef> // for std::byte
+#include <cstdint>
+#include <memory>
+#include <string_view>
+
+template <typename T>
+static std::shared_ptr<std::atomic<T>> MakeAtomicField(RNTupleModel &model,
+                                                       std::string_view name) {
+  return model.MakeField<std::atomic<T>>(name);
+}
+
+void write(std::string_view filename = "types.atomic.root") {
+  auto model = RNTupleModel::Create();
+
+  auto Bit = MakeAtomicField<bool>(*model, "Bit");
+  auto Byte = MakeAtomicField<std::byte>(*model, "Byte");
+  auto Char = MakeAtomicField<char>(*model, "Char");
+
+  auto Int8 = MakeAtomicField<std::int8_t>(*model, "Int8");
+  auto UInt8 = MakeAtomicField<std::uint8_t>(*model, "UInt8");
+  auto Int16 = MakeAtomicField<std::int16_t>(*model, "Int16");
+  auto UInt16 = MakeAtomicField<std::uint16_t>(*model, "UInt16");
+  auto Int32 = MakeAtomicField<std::int32_t>(*model, "Int32");
+  auto UInt32 = MakeAtomicField<std::uint32_t>(*model, "UInt32");
+  auto Int64 = MakeAtomicField<std::int64_t>(*model, "Int64");
+  auto UInt64 = MakeAtomicField<std::uint64_t>(*model, "UInt64");
+
+  auto Real32 = MakeAtomicField<float>(*model, "Real32");
+  auto Real64 = MakeAtomicField<double>(*model, "Real64");
+
+  RNTupleWriteOptions options;
+  options.SetCompression(0);
+  auto writer =
+      RNTupleWriter::Recreate(std::move(model), "ntpl", filename, options);
+
+  // First entry: ascending values
+  *Bit = 1;
+  *Byte = std::byte{2};
+  *Char = 3;
+  *Int8 = 4;
+  *UInt8 = 5;
+  *Int16 = 6;
+  *UInt16 = 7;
+  *Int32 = 8;
+  *UInt32 = 9;
+  *Int64 = 10;
+  *UInt64 = 11;
+  *Real32 = 12.0f;
+  *Real64 = 13.0;
+  writer->Fill();
+
+  // Second entry: zero values
+  *Bit = 0;
+  *Byte = std::byte{0};
+  *Char = 0;
+  *Int8 = 0;
+  *UInt8 = 0;
+  *Int16 = 0;
+  *UInt16 = 0;
+  *Int32 = 0;
+  *UInt32 = 0;
+  *Int64 = 0;
+  *UInt64 = 0;
+  *Real32 = 0;
+  *Real64 = 0;
+  writer->Fill();
+}