From bda686a434ed1854615b5b0306abff31207ce2ba Mon Sep 17 00:00:00 2001
From: George Evmenov <altren@gmail.com>
Date: Mon, 26 Oct 2026 15:22:12 +0300
Subject: [PATCH 1/2] Add bulk numeric array I/O for Cereal, YAS, and Boost
 binary

---
 benchmarks/all/bulk_numeric_arrays_cereal.cpp |  85 ++++++++
 include/rfl/boost_serialization/Parser.hpp    |  41 ++++
 include/rfl/cereal/Parser.hpp                 |  38 ++++
 include/rfl/yas/Parser.hpp                    |  37 ++++
 .../test_numeric_array_io.cpp                 | 113 ++++++++++
 tests/cereal/test_numeric_array_io.cpp        | 194 ++++++++++++++++++
 tests/check_numeric_array_io.hpp              | 140 +++++++++++++
 tests/yas/test_numeric_array_io.cpp           |  50 +++++
 8 files changed, 698 insertions(+)
 create mode 100644 benchmarks/all/bulk_numeric_arrays_cereal.cpp
 create mode 100644 tests/boost_serialization/test_numeric_array_io.cpp
 create mode 100644 tests/cereal/test_numeric_array_io.cpp
 create mode 100644 tests/check_numeric_array_io.hpp
 create mode 100644 tests/yas/test_numeric_array_io.cpp

diff --git a/benchmarks/all/bulk_numeric_arrays_cereal.cpp b/benchmarks/all/bulk_numeric_arrays_cereal.cpp
new file mode 100644
index 000000000..58efad76c
--- /dev/null
+++ b/benchmarks/all/bulk_numeric_arrays_cereal.cpp
@@ -0,0 +1,85 @@
+#include <benchmark/benchmark.h>
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <rfl/cereal.hpp>
+
+namespace bulk_numeric_arrays_cereal {
+
+struct Pose {
+  std::array<double, 4> rotation;
+  std::array<double, 3> translation;
+
+  bool operator==(const Pose&) const = default;
+};
+
+template <class T, std::size_t N>
+std::array<T, N> make_array() {
+  std::array<T, N> values;
+  for (std::size_t i = 0; i < N; ++i) {
+    values[i] = static_cast<T>((i * 17 + 3) % 251);
+  }
+  return values;
+}
+
+template <bool Read, class T>
+void run(benchmark::State& state, T input) {
+  const auto bytes = rfl::cereal::write(input);
+  const auto decoded = rfl::cereal::read<T>(bytes);
+  if (!decoded || *decoded != input) {
+    state.SkipWithError("Cereal round trip changed the input");
+    return;
+  }
+
+  // Time the public byte-container APIs, including stream setup and output
+  // allocation. Fixture generation and correctness checks are outside the loop.
+  for (auto _ : state) {
+    if constexpr (Read) {
+      auto result = rfl::cereal::read<T>(bytes);
+      benchmark::DoNotOptimize(result);
+    } else {
+      benchmark::DoNotOptimize(input);
+      auto result = rfl::cereal::write(input);
+      benchmark::DoNotOptimize(result);
+    }
+    benchmark::ClobberMemory();
+  }
+  state.SetItemsProcessed(state.iterations());
+  state.SetBytesProcessed(state.iterations() *
+                          static_cast<std::int64_t>(bytes.size()));
+  state.counters["serialized_bytes"] = static_cast<double>(bytes.size());
+}
+
+template <bool Read, class T, std::size_t N>
+void BM_array(benchmark::State& state) {
+  run<Read>(state, make_array<T, N>());
+}
+
+template <bool Read>
+void BM_pose(benchmark::State& state) {
+  run<Read>(state, Pose{{0.0, 0.0, 0.0, 1.0}, {1.25, -2.5, 3.75}});
+}
+
+#define RFL_CEREAL_ARRAY_BENCHMARK(T, N)                       \
+  BENCHMARK_TEMPLATE(BM_array, true, T, N)                     \
+      ->Name("bulk_numeric_arrays/cereal/" #T "_" #N "/read"); \
+  BENCHMARK_TEMPLATE(BM_array, false, T, N)                    \
+      ->Name("bulk_numeric_arrays/cereal/" #T "_" #N "/write")
+
+RFL_CEREAL_ARRAY_BENCHMARK(double, 2);
+RFL_CEREAL_ARRAY_BENCHMARK(double, 3);
+RFL_CEREAL_ARRAY_BENCHMARK(double, 4);
+RFL_CEREAL_ARRAY_BENCHMARK(double, 9);
+RFL_CEREAL_ARRAY_BENCHMARK(double, 16);
+RFL_CEREAL_ARRAY_BENCHMARK(double, 36);
+RFL_CEREAL_ARRAY_BENCHMARK(float, 128);
+RFL_CEREAL_ARRAY_BENCHMARK(std::uint8_t, 32);
+
+#undef RFL_CEREAL_ARRAY_BENCHMARK
+
+BENCHMARK_TEMPLATE(BM_pose, true)->Name("bulk_numeric_arrays/cereal/pose/read");
+BENCHMARK_TEMPLATE(BM_pose, false)
+    ->Name("bulk_numeric_arrays/cereal/pose/write");
+
+}  // namespace bulk_numeric_arrays_cereal
diff --git a/include/rfl/boost_serialization/Parser.hpp b/include/rfl/boost_serialization/Parser.hpp
index ddc9ec079..e71cceeb5 100644
--- a/include/rfl/boost_serialization/Parser.hpp
+++ b/include/rfl/boost_serialization/Parser.hpp
@@ -1,6 +1,7 @@
 #ifndef RFL_BOOST_SERIALIZATION_PARSER_HPP_
 #define RFL_BOOST_SERIALIZATION_PARSER_HPP_
 
+#include <array>
 #include <boost/archive/binary_iarchive.hpp>
 #include <boost/archive/binary_oarchive.hpp>
 #include <cstddef>
@@ -22,6 +23,46 @@
 namespace rfl {
 namespace parsing {
 
+// Keep bool on the generic path to retain Boost's scalar validity assertions.
+// Other archive types (including text archives) keep their generic parser too.
+template <class T, std::size_t N, class ProcessorsType>
+  requires(std::is_arithmetic_v<T> && !std::is_same_v<T, bool> &&
+           !std::is_const_v<T> && !std::is_volatile_v<T>)
+struct Parser<boost_serialization::Reader<::boost::archive::binary_iarchive>,
+              boost_serialization::Writer<::boost::archive::binary_oarchive>,
+              std::array<T, N>, ProcessorsType>
+    : ParserArray<
+          boost_serialization::Reader<::boost::archive::binary_iarchive>,
+          boost_serialization::Writer<::boost::archive::binary_oarchive>, T, N,
+          ProcessorsType> {
+  using R = boost_serialization::Reader<::boost::archive::binary_iarchive>;
+  using W = boost_serialization::Writer<::boost::archive::binary_oarchive>;
+  using Type = std::array<T, N>;
+
+  static Result<Type> read(const R&,
+                           const typename R::InputVarType& _var) noexcept {
+    try {
+      Type values;
+      if constexpr (N != 0) {
+        _var.ar->load_binary(values.data(), N * sizeof(T));
+      }
+      return values;
+    } catch (const std::exception& e) {
+      return error(std::string("Boost binary array read error: ") + e.what());
+    }
+  }
+
+  template <class ParentType>
+  static void write(const W& _w, const Type& _values,
+                    const ParentType& _parent) {
+    auto arr = Parent<W>::add_fixed_array(_w, N, _parent);
+    if constexpr (N != 0) {
+      _w.write_array_data(_values.data(), N);
+    }
+    _w.end_array(&arr);
+  }
+};
+
 template <class T, class ProcessorsType>
   requires(std::is_arithmetic_v<T> && !std::is_same_v<T, bool> &&
            !std::is_same_v<T, char>)
diff --git a/include/rfl/cereal/Parser.hpp b/include/rfl/cereal/Parser.hpp
index 616f2f6f6..ad66b7704 100644
--- a/include/rfl/cereal/Parser.hpp
+++ b/include/rfl/cereal/Parser.hpp
@@ -1,6 +1,7 @@
 #ifndef RFL_CEREAL_PARSER_HPP_
 #define RFL_CEREAL_PARSER_HPP_
 
+#include <array>
 #include <cstddef>
 #include <exception>
 #include <string>
@@ -15,6 +16,43 @@
 namespace rfl {
 namespace parsing {
 
+template <class T, std::size_t N, class ProcessorsType>
+  requires(std::is_arithmetic_v<T> && !std::is_const_v<T> &&
+           !std::is_volatile_v<T>)
+struct Parser<cereal::Reader, cereal::Writer, std::array<T, N>, ProcessorsType>
+    : ParserArray<cereal::Reader, cereal::Writer, T, N, ProcessorsType> {
+  using R = cereal::Reader;
+  using W = cereal::Writer;
+  using Type = std::array<T, N>;
+
+  static Result<Type> read(const R&,
+                           const typename R::InputVarType& _var) noexcept {
+    try {
+      Type values;
+      if constexpr (N != 0) {
+        // Keep the typed pointer: portable binary swaps each T separately.
+        (*_var.archive_)(::cereal::binary_data(values.data(), N * sizeof(T)));
+      }
+      return values;
+    } catch (const std::exception& e) {
+      return error(std::string("Cereal array read error: ") + e.what());
+    }
+  }
+
+  template <class ParentType>
+  static void write(const W& _w, const Type& _values,
+                    const ParentType& _parent) {
+    // Even empty arrays need parent metadata, but never a length prefix.
+    auto arr = Parent<W>::add_fixed_array(_w, N, _parent);
+    if constexpr (N != 0) {
+      // Cereal encodes arithmetic scalars (including bool and character types)
+      // as sizeof(T) bytes, just like this contiguous std::array payload.
+      _w.write_array_data(_values.data(), N);
+    }
+    _w.end_array(&arr);
+  }
+};
+
 template <class T, class ProcessorsType>
   requires(std::is_arithmetic_v<T> && !std::is_same_v<T, bool> &&
            !std::is_same_v<T, char>)
diff --git a/include/rfl/yas/Parser.hpp b/include/rfl/yas/Parser.hpp
index d7ede37c5..3f9a622be 100644
--- a/include/rfl/yas/Parser.hpp
+++ b/include/rfl/yas/Parser.hpp
@@ -1,6 +1,7 @@
 #ifndef RFL_YAS_PARSER_HPP_
 #define RFL_YAS_PARSER_HPP_
 
+#include <array>
 #include <cstddef>
 #include <exception>
 #include <string>
@@ -19,6 +20,42 @@
 namespace rfl {
 namespace parsing {
 
+template <class T, std::size_t N, class ProcessorsType>
+  requires((std::is_integral_v<T> || std::is_same_v<T, float> ||
+            std::is_same_v<T, double>) &&
+           !std::is_const_v<T> && !std::is_volatile_v<T>)
+struct Parser<yas::Reader, yas::Writer, std::array<T, N>, ProcessorsType>
+    : ParserArray<yas::Reader, yas::Writer, T, N, ProcessorsType> {
+  using R = yas::Reader;
+  using W = yas::Writer;
+  using Type = std::array<T, N>;
+
+  static Result<Type> read(const R&,
+                           const typename R::InputVarType& _var) noexcept {
+    try {
+      Type values;
+      if constexpr (N != 0) {
+        // This adapter uses YAS's non-compacted, host-endian binary archive.
+        _var.ar->read(values.data(), N * sizeof(T));
+      }
+      return values;
+    } catch (const std::exception& e) {
+      return error(std::string("yas array read error: ") + e.what());
+    }
+  }
+
+  template <class ParentType>
+  static void write(const W& _w, const Type& _values,
+                    const ParentType& _parent) {
+    auto arr = Parent<W>::add_fixed_array(_w, N, _parent);
+    if constexpr (N != 0) {
+      // bool and character scalars also use their native representation.
+      arr.ar->write(_values.data(), N * sizeof(T));
+    }
+    _w.end_array(&arr);
+  }
+};
+
 template <class T, class ProcessorsType>
   requires((std::is_integral_v<T> || std::is_same_v<T, float> ||
             std::is_same_v<T, double>) &&
diff --git a/tests/boost_serialization/test_numeric_array_io.cpp b/tests/boost_serialization/test_numeric_array_io.cpp
new file mode 100644
index 000000000..89acc2ef1
--- /dev/null
+++ b/tests/boost_serialization/test_numeric_array_io.cpp
@@ -0,0 +1,113 @@
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <rfl/NoFieldNames.hpp>
+#include <rfl/boost_serialization.hpp>
+#include <rfl/parsing/ParserArray.hpp>
+#include <sstream>
+
+#include "../check_numeric_array_io.hpp"
+
+namespace rfl::parsing {
+template <class T, std::size_t N, class... Ps>
+struct Parser<boost_serialization::Reader<::boost::archive::binary_iarchive>,
+              boost_serialization::Writer<::boost::archive::binary_oarchive>,
+              std::array<T, N>,
+              Processors<test_numeric_array_io::GenericArrays, Ps...>>
+    : ParserArray<
+          boost_serialization::Reader<::boost::archive::binary_iarchive>,
+          boost_serialization::Writer<::boost::archive::binary_oarchive>, T, N,
+          Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
+}  // namespace rfl::parsing
+
+namespace test_numeric_array_io {
+namespace {
+template <class... Ps>
+constexpr auto write = [](const auto& input) {
+  return rfl::boost_serialization::write<Ps...>(input);
+};
+
+template <class... Ps>
+constexpr auto read = []<class T>(const auto& bytes) {
+  return rfl::boost_serialization::read<T, Ps...>(bytes);
+};
+
+template <class... Ps>
+void check(const auto& input) {
+  check_compatible(input, write<Ps...>, read<Ps...>,
+                   write<GenericArrays, Ps...>, read<GenericArrays, Ps...>);
+}
+}  // namespace
+
+TEST(boost_serialization, numeric_array_wire_compatibility) {
+  check_types(write<>, read<>, write<GenericArrays>, read<GenericArrays>);
+}
+
+TEST(boost_serialization, numeric_array_parents) {
+  check_parents([](const auto& input) { check(input); });
+  check_parents([](const auto& input) { check<rfl::NoFieldNames>(input); });
+}
+
+TEST(boost_serialization, numeric_array_non_arithmetic_fallback) {
+  check_non_arithmetic([](const auto& input) { check(input); });
+}
+
+TEST(boost_serialization, numeric_array_truncated_input) {
+  check_truncated(write<>, read<>);
+  check_truncated(write<>, read<GenericArrays>);
+}
+
+TEST(boost_serialization, numeric_array_text_archive_fallback) {
+  using I = boost::archive::text_iarchive;
+  using O = boost::archive::text_oarchive;
+  using R = rfl::boost_serialization::Reader<I>;
+  using W = rfl::boost_serialization::Writer<O>;
+  const std::array<double, 3> input{1.25, -2.5, 0.0};
+  std::ostringstream output;
+  {
+    O archive(output);
+    rfl::boost_serialization::write<I>(archive, input);
+  }
+  std::ostringstream generic;
+  {
+    O archive(generic);
+    const W writer(&archive);
+    rfl::parsing::ParserArray<R, W, double, 3, rfl::Processors<>>::write(
+        writer, input, rfl::parsing::Parent<W>::Root{});
+  }
+  EXPECT_EQ(output.str(), generic.str());
+  std::istringstream stream(output.str());
+  I archive(stream);
+  const auto decoded =
+      rfl::boost_serialization::read_from_archive<std::array<double, 3>, I, O>(
+          archive);
+  ASSERT_TRUE(decoded) << decoded.error().what();
+  EXPECT_EQ(*decoded, input);
+}
+
+TEST(boost_serialization, numeric_array_binary_archive_options) {
+  using I = boost::archive::binary_iarchive;
+  using O = boost::archive::binary_oarchive;
+  const std::array<long double, 3> input{1.25L, -2.5L, 3.75L};
+  for (const auto flags : {0u, unsigned(boost::archive::no_header |
+                                        boost::archive::no_tracking)}) {
+    const auto serialize = [&]<class... Ps>(rfl::Processors<Ps...>) {
+      std::ostringstream stream;
+      {
+        O archive(stream, flags);
+        rfl::boost_serialization::write<I, O, Ps...>(archive, input);
+      }
+      return stream.str();
+    };
+    const auto bytes = serialize(rfl::Processors<>{});
+    EXPECT_EQ(bytes, serialize(rfl::Processors<GenericArrays>{}));
+    std::istringstream stream(bytes);
+    I archive(stream, flags);
+    const auto decoded =
+        rfl::boost_serialization::read_from_archive<std::array<long double, 3>,
+                                                    I, O>(archive);
+    ASSERT_TRUE(decoded) << decoded.error().what();
+    EXPECT_EQ(*decoded, input);
+  }
+}
+
+}  // namespace test_numeric_array_io
diff --git a/tests/cereal/test_numeric_array_io.cpp b/tests/cereal/test_numeric_array_io.cpp
new file mode 100644
index 000000000..1c7ca2f86
--- /dev/null
+++ b/tests/cereal/test_numeric_array_io.cpp
@@ -0,0 +1,194 @@
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <map>
+#include <optional>
+#include <rfl/NoFieldNames.hpp>
+#include <rfl/cereal.hpp>
+#include <rfl/parsing/ParserArray.hpp>
+#include <sstream>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "../check_numeric_array_io.hpp"
+
+namespace rfl::parsing {
+template <class T, std::size_t N, class... Ps>
+struct Parser<cereal::Reader, cereal::Writer, std::array<T, N>,
+              Processors<test_numeric_array_io::GenericArrays, Ps...>>
+    : ParserArray<cereal::Reader, cereal::Writer, T, N,
+                  Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
+}  // namespace rfl::parsing
+
+namespace test_numeric_array_io {
+namespace {
+using Archive = ::cereal::PortableBinaryOutputArchive;
+
+template <class... Ps, class T>
+std::string write(const T& input, Archive::Options options) {
+  std::ostringstream stream;
+  Archive archive(stream, options);
+  rfl::cereal::write<T, Ps...>(input, archive);
+  return stream.str();
+}
+
+template <class... Ps, class T>
+void check_compatible(const T& input) {
+  for (const auto options :
+       {Archive::Options::LittleEndian(), Archive::Options::BigEndian()}) {
+    const auto generic = write<GenericArrays, Ps...>(input, options);
+    const auto bulk = write<Ps...>(input, options);
+    EXPECT_EQ(bulk, generic);
+    const auto decoded = rfl::cereal::read<T, Ps...>(generic);
+    ASSERT_TRUE(decoded) << decoded.error().what();
+    EXPECT_EQ(*decoded, input);
+    const auto generic_decoded =
+        rfl::cereal::read<T, GenericArrays, Ps...>(bulk);
+    ASSERT_TRUE(generic_decoded) << generic_decoded.error().what();
+    EXPECT_EQ(*generic_decoded, input);
+    EXPECT_EQ(write<Ps...>(*decoded, options), generic);
+  }
+}
+
+template <class T>
+void check_type() {
+  check_compatible(std::array<T, 0>{});
+  check_compatible(std::array<T, 1>{T(1)});
+  check_compatible(std::array<T, 4>{std::numeric_limits<T>::lowest(), T(0),
+                                    T(1), std::numeric_limits<T>::max()});
+  std::array<T, 65> many{};
+  for (std::size_t i = 0; i < many.size(); ++i) many[i] = T(i % 17);
+  check_compatible(many);
+  if constexpr (std::is_floating_point_v<T>) {
+    check_compatible(std::array<T, 5>{-T(0), T(1.25), -T(2.5),
+                                      std::numeric_limits<T>::infinity(),
+                                      -std::numeric_limits<T>::infinity()});
+    const std::array<T, 1> nan{std::numeric_limits<T>::quiet_NaN()};
+    for (const auto options :
+         {Archive::Options::LittleEndian(), Archive::Options::BigEndian()}) {
+      const auto bytes = write<GenericArrays>(nan, options);
+      EXPECT_EQ(write(nan, options), bytes);
+      const auto decoded = rfl::cereal::read<std::array<T, 1>>(bytes);
+      ASSERT_TRUE(decoded) << decoded.error().what();
+      EXPECT_TRUE(std::isnan(decoded->front()));
+      EXPECT_EQ(write(*decoded, options), bytes);
+    }
+  }
+}
+
+}  // namespace
+
+TEST(cereal, numeric_array_wire_compatibility) {
+  check_type<std::int8_t>();
+  check_type<std::uint8_t>();
+  check_type<std::int16_t>();
+  check_type<std::uint16_t>();
+  check_type<std::int32_t>();
+  check_type<std::uint32_t>();
+  check_type<std::int64_t>();
+  check_type<std::uint64_t>();
+  check_type<float>();
+  check_type<double>();
+}
+
+TEST(cereal, numeric_array_long_double) {
+  const std::array<long double, 3> input{1.25L, -2.5L, 3.75L};
+  for (const auto options :
+       {Archive::Options::LittleEndian(), Archive::Options::BigEndian()}) {
+    const auto bytes = write<GenericArrays>(input, options);
+    EXPECT_EQ(write(input, options), bytes);
+    const auto decoded = rfl::cereal::read<std::array<long double, 3>>(bytes);
+    ASSERT_TRUE(decoded) << decoded.error().what();
+    EXPECT_EQ(*decoded, input);
+    // Do not compare reserialized padding: some long double representations
+    // have padding bytes which need not survive copying the decoded values.
+  }
+}
+
+TEST(cereal, numeric_array_bool_and_characters) {
+  check_type<bool>();
+  check_type<char>();
+  check_type<signed char>();
+  check_type<unsigned char>();
+  check_type<wchar_t>();
+  check_type<char8_t>();
+  check_type<char16_t>();
+  check_type<char32_t>();
+  check_compatible(std::array<char, 4>{'a', '\0', 'z', '\xff'});
+}
+
+TEST(cereal, numeric_array_parents) {
+  check_parents([](const auto& input) { check_compatible(input); });
+  check_parents(
+      [](const auto& input) { check_compatible<rfl::NoFieldNames>(input); });
+}
+
+TEST(cereal, numeric_array_non_arithmetic_fallback) {
+  check_compatible(std::array<std::string, 2>{"hello", "world"});
+  check_compatible(std::array<Nested, 1>{
+      Nested{{1.0, 2.0, 3.0}, {}, {}, {}, std::nullopt, 1, 42}});
+}
+
+TEST(cereal, numeric_array_truncated_input) {
+  using Array = std::array<double, 3>;
+  for (const auto options :
+       {Archive::Options::LittleEndian(), Archive::Options::BigEndian()}) {
+    const auto bytes = write<GenericArrays>(Array{1.25, -2.5, 3.75}, options);
+    EXPECT_EQ(bytes.size(), 1u + 3 * sizeof(double));
+    for (std::size_t size = 0; size < bytes.size(); ++size) {
+      SCOPED_TRACE(size);
+      const auto decoded = rfl::cereal::read<Array>(bytes.data(), size);
+      ASSERT_FALSE(decoded);
+      EXPECT_NE(decoded.error().what().find("Failed to read"),
+                std::string::npos);
+      if (size != 0) {
+        EXPECT_NE(decoded.error().what().find("Cereal array read error"),
+                  std::string::npos);
+      }
+      EXPECT_FALSE(
+          (rfl::cereal::read<Array, GenericArrays>(bytes.data(), size)));
+    }
+    const auto empty = write(std::array<double, 0>{}, options);
+    EXPECT_EQ(empty.size(), 1u);
+    EXPECT_TRUE((rfl::cereal::read<std::array<double, 0>>(empty)));
+    EXPECT_FALSE((rfl::cereal::read<std::array<double, 0>>(empty.data(), 0)));
+  }
+}
+
+TEST(cereal, numeric_array_single_binary_operation) {
+  struct Buffer : std::stringbuf {
+    std::size_t reads = 0;
+    std::size_t writes = 0;
+    std::streamsize xsgetn(char* data, std::streamsize size) override {
+      ++reads;
+      return std::stringbuf::xsgetn(data, size);
+    }
+    std::streamsize xsputn(const char* data, std::streamsize size) override {
+      ++writes;
+      return std::stringbuf::xsputn(data, size);
+    }
+  } buffer;
+  const std::array<double, 9> input{1, 2, 3, 4, 5, 6, 7, 8, 9};
+  std::ostream output(&buffer);
+  Archive output_archive(output);
+  buffer.writes = 0;  // Exclude the portable-binary endian marker.
+  rfl::cereal::write(input, output_archive);
+  EXPECT_EQ(buffer.writes, 1u);
+  rfl::cereal::write(std::array<double, 0>{}, output_archive);
+  EXPECT_EQ(buffer.writes, 1u);
+  std::istream stream(&buffer);
+  ::cereal::PortableBinaryInputArchive input_archive(stream);
+  buffer.reads = 0;
+  const auto decoded = rfl::cereal::read<std::array<double, 9>>(input_archive);
+  ASSERT_TRUE(decoded) << decoded.error().what();
+  EXPECT_EQ(*decoded, input);
+  EXPECT_EQ(buffer.reads, 1u);
+  EXPECT_TRUE((rfl::cereal::read<std::array<double, 0>>(input_archive)));
+  EXPECT_EQ(buffer.reads, 1u);
+}
+
+}  // namespace test_numeric_array_io
diff --git a/tests/check_numeric_array_io.hpp b/tests/check_numeric_array_io.hpp
new file mode 100644
index 000000000..f2e345d77
--- /dev/null
+++ b/tests/check_numeric_array_io.hpp
@@ -0,0 +1,140 @@
+#ifndef CHECK_NUMERIC_ARRAY_IO_HPP_
+#define CHECK_NUMERIC_ARRAY_IO_HPP_
+
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <map>
+#include <optional>
+#include <rfl/Processors.hpp>
+#include <string>
+#include <tuple>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+namespace test_numeric_array_io {
+// Select the existing element-by-element array parser in backend test adapters.
+struct GenericArrays : rfl::Processors<> {};
+
+struct Nested {
+  std::array<double, 3> values;
+  std::array<double, 0> empty;
+  std::vector<std::array<double, 2>> rows;
+  std::map<std::string, std::array<float, 2>> lookup;
+  std::optional<std::array<int, 2>> optional;
+  std::variant<int, std::array<double, 2>> choice;
+  int tail;
+
+  bool operator==(const Nested&) const = default;
+};
+
+template <class T, class Write, class Read, class GenericWrite,
+          class GenericRead>
+void check_compatible(const T& input, Write write, Read read,
+                      GenericWrite generic_write, GenericRead generic_read) {
+  const auto generic = generic_write(input);
+  const auto bulk = write(input);
+  EXPECT_EQ(bulk, generic);
+  const auto decoded = read.template operator()<T>(generic);
+  ASSERT_TRUE(decoded) << decoded.error().what();
+  EXPECT_EQ(*decoded, input);
+  const auto generic_decoded = generic_read.template operator()<T>(bulk);
+  ASSERT_TRUE(generic_decoded) << generic_decoded.error().what();
+  EXPECT_EQ(*generic_decoded, input);
+  EXPECT_EQ(write(*decoded), generic);
+}
+
+template <class T, class Check, class Write, class Read, class GenericWrite>
+void check_type(Check check, Write write, Read read,
+                GenericWrite generic_write) {
+  check(std::array<T, 0>{});
+  check(std::array<T, 1>{T(1)});
+  check(std::array<T, 4>{std::numeric_limits<T>::lowest(), T(0), T(1),
+                         std::numeric_limits<T>::max()});
+  std::array<T, 65> many{};
+  for (std::size_t i = 0; i < many.size(); ++i) many[i] = T(i % 17);
+  check(many);
+  if constexpr (std::is_floating_point_v<T>) {
+    check(std::array<T, 5>{-T(0), T(1.25), -T(2.5),
+                           std::numeric_limits<T>::infinity(),
+                           -std::numeric_limits<T>::infinity()});
+    const std::array<T, 1> nan{std::numeric_limits<T>::quiet_NaN()};
+    const auto bytes = generic_write(nan);
+    EXPECT_EQ(write(nan), bytes);
+    const auto decoded = read.template operator()<std::array<T, 1>>(bytes);
+    ASSERT_TRUE(decoded) << decoded.error().what();
+    EXPECT_TRUE(std::isnan(decoded->front()));
+    EXPECT_EQ(write(*decoded), bytes);
+  }
+}
+
+template <class Write, class Read, class GenericWrite, class GenericRead>
+void check_types(Write write, Read read, GenericWrite generic_write,
+                 GenericRead generic_read) {
+  const auto check = [&](const auto& input) {
+    check_compatible(input, write, read, generic_write, generic_read);
+  };
+  [&]<class... Ts>(std::tuple<Ts...>*) {
+    (check_type<Ts>(check, write, read, generic_write), ...);
+  }(static_cast<std::tuple<
+        std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t,
+        std::uint32_t, std::int64_t, std::uint64_t, float, double, bool, char,
+        signed char, unsigned char, wchar_t, char8_t, char16_t, char32_t>*>(
+      nullptr));
+  check(std::array<char, 4>{'a', '\0', 'z', '\xff'});
+}
+
+template <class Check>
+void check_parents(Check check) {
+  const Nested input{{1.25, -2.5, 3.75},
+                     {},
+                     {{4.5, -6.25}, {7.0, 8.5}},
+                     {{"key", {0.5f, -1.5f}}},
+                     std::array<int, 2>{9, 10},
+                     std::array<double, 2>{11.5, -12.25},
+                     42};
+  check(input);
+  check(std::array<std::array<double, 2>, 2>{{{1.25, -2.5}, {3.75, -4.5}}});
+  check(std::array<std::array<double, 0>, 3>{});
+  check(std::array<std::vector<int>, 2>{{{1, 2}, {}}});
+  check(std::variant<int, std::array<double, 0>>{std::array<double, 0>{}});
+  check(std::map<std::string, std::array<double, 0>>{{"first", {}},
+                                                     {"second", {}}});
+  check(std::map<int, std::array<double, 2>>{{1, {1.25, -2.5}},
+                                             {2, {3.75, -4.5}}});
+  check(std::map<std::array<int, 2>, std::array<double, 2>>{
+      {{1, 2}, {1.25, -2.5}}, {{3, 4}, {3.75, -4.5}}});
+  check(std::map<std::array<int, 0>, std::array<double, 0>>{{{}, {}}});
+}
+
+template <class Check>
+void check_non_arithmetic(Check check) {
+  check(std::array<std::string, 2>{"hello", "world"});
+  check(std::array<Nested, 1>{
+      Nested{{1.0, 2.0, 3.0}, {}, {}, {}, std::nullopt, 1, 42}});
+}
+
+template <class Write, class Read>
+void check_truncated(Write write, Read read) {
+  using Array = std::array<double, 3>;
+  const auto bytes = write(Array{1.25, -2.5, 3.75});
+  for (std::size_t size = 0; size < bytes.size(); ++size) {
+    SCOPED_TRACE(size);
+    const std::vector<char> truncated(bytes.begin(), bytes.begin() + size);
+    const auto decoded = read.template operator()<Array>(truncated);
+    ASSERT_FALSE(decoded);
+    EXPECT_FALSE(decoded.error().what().empty());
+  }
+  const auto empty = write(std::array<double, 0>{});
+  EXPECT_EQ(empty.size(), bytes.size() - 3 * sizeof(double));
+  EXPECT_TRUE((read.template operator()<std::array<double, 0>>(empty)));
+}
+
+}  // namespace test_numeric_array_io
+
+#endif
diff --git a/tests/yas/test_numeric_array_io.cpp b/tests/yas/test_numeric_array_io.cpp
new file mode 100644
index 000000000..e054b4d39
--- /dev/null
+++ b/tests/yas/test_numeric_array_io.cpp
@@ -0,0 +1,50 @@
+#include <rfl/NoFieldNames.hpp>
+#include <rfl/parsing/ParserArray.hpp>
+#include <rfl/yas.hpp>
+
+#include "../check_numeric_array_io.hpp"
+
+namespace rfl::parsing {
+template <class T, std::size_t N, class... Ps>
+struct Parser<yas::Reader, yas::Writer, std::array<T, N>,
+              Processors<test_numeric_array_io::GenericArrays, Ps...>>
+    : ParserArray<yas::Reader, yas::Writer, T, N,
+                  Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
+}  // namespace rfl::parsing
+
+namespace test_numeric_array_io {
+namespace {
+template <class... Ps>
+constexpr auto write =
+    [](const auto& input) { return rfl::yas::write<Ps...>(input); };
+
+template <class... Ps>
+constexpr auto read =
+    []<class T>(const auto& bytes) { return rfl::yas::read<T, Ps...>(bytes); };
+
+template <class... Ps>
+void check(const auto& input) {
+  check_compatible(input, write<Ps...>, read<Ps...>,
+                   write<GenericArrays, Ps...>, read<GenericArrays, Ps...>);
+}
+}  // namespace
+
+TEST(yas, numeric_array_wire_compatibility) {
+  check_types(write<>, read<>, write<GenericArrays>, read<GenericArrays>);
+}
+
+TEST(yas, numeric_array_parents) {
+  check_parents([](const auto& input) { check(input); });
+  check_parents([](const auto& input) { check<rfl::NoFieldNames>(input); });
+}
+
+TEST(yas, numeric_array_non_arithmetic_fallback) {
+  check_non_arithmetic([](const auto& input) { check(input); });
+}
+
+TEST(yas, numeric_array_truncated_input) {
+  check_truncated(write<>, read<>);
+  check_truncated(write<>, read<GenericArrays>);
+}
+
+}  // namespace test_numeric_array_io

From b6ac85d487d4a55392912f864a6f4ba08da62c81 Mon Sep 17 00:00:00 2001
From: George Evmenov <altren@gmail.com>
Date: Mon, 26 Oct 2026 16:18:48 +0300
Subject: [PATCH 2/2] Fix GCC 13 warnings in numeric array compatibility tests

---
 .../test_numeric_array_io.cpp                 |  8 +++-
 tests/cereal/test_numeric_array_io.cpp        |  5 ++-
 tests/check_numeric_array_io.hpp              | 38 +++++++++++++++++--
 tests/yas/test_numeric_array_io.cpp           |  5 ++-
 4 files changed, 46 insertions(+), 10 deletions(-)

diff --git a/tests/boost_serialization/test_numeric_array_io.cpp b/tests/boost_serialization/test_numeric_array_io.cpp
index 89acc2ef1..0c4f0c65a 100644
--- a/tests/boost_serialization/test_numeric_array_io.cpp
+++ b/tests/boost_serialization/test_numeric_array_io.cpp
@@ -13,7 +13,7 @@ struct Parser<boost_serialization::Reader<::boost::archive::binary_iarchive>,
               boost_serialization::Writer<::boost::archive::binary_oarchive>,
               std::array<T, N>,
               Processors<test_numeric_array_io::GenericArrays, Ps...>>
-    : ParserArray<
+    : test_numeric_array_io::GenericArrayParser<
           boost_serialization::Reader<::boost::archive::binary_iarchive>,
           boost_serialization::Writer<::boost::archive::binary_oarchive>, T, N,
           Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
@@ -39,7 +39,11 @@ void check(const auto& input) {
 }  // namespace
 
 TEST(boost_serialization, numeric_array_wire_compatibility) {
-  check_types(write<>, read<>, write<GenericArrays>, read<GenericArrays>);
+  // bool deliberately retains the production generic parser, whose N == 1
+  // raw buffer triggers GCC 13's -Wmaybe-uninitialized false positive. Keep
+  // bool coverage at N == 0, 4, and 65; all optimized types also test N == 1.
+  check_types<false>(write<>, read<>, write<GenericArrays>,
+                     read<GenericArrays>);
 }
 
 TEST(boost_serialization, numeric_array_parents) {
diff --git a/tests/cereal/test_numeric_array_io.cpp b/tests/cereal/test_numeric_array_io.cpp
index 1c7ca2f86..8d8a188c3 100644
--- a/tests/cereal/test_numeric_array_io.cpp
+++ b/tests/cereal/test_numeric_array_io.cpp
@@ -20,8 +20,9 @@ namespace rfl::parsing {
 template <class T, std::size_t N, class... Ps>
 struct Parser<cereal::Reader, cereal::Writer, std::array<T, N>,
               Processors<test_numeric_array_io::GenericArrays, Ps...>>
-    : ParserArray<cereal::Reader, cereal::Writer, T, N,
-                  Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
+    : test_numeric_array_io::GenericArrayParser<
+          cereal::Reader, cereal::Writer, T, N,
+          Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
 }  // namespace rfl::parsing
 
 namespace test_numeric_array_io {
diff --git a/tests/check_numeric_array_io.hpp b/tests/check_numeric_array_io.hpp
index f2e345d77..46735e061 100644
--- a/tests/check_numeric_array_io.hpp
+++ b/tests/check_numeric_array_io.hpp
@@ -11,6 +11,8 @@
 #include <map>
 #include <optional>
 #include <rfl/Processors.hpp>
+#include <rfl/parsing/ArrayReader.hpp>
+#include <rfl/parsing/ParserArray.hpp>
 #include <string>
 #include <tuple>
 #include <type_traits>
@@ -21,6 +23,30 @@ namespace test_numeric_array_io {
 // Select the existing element-by-element array parser in backend test adapters.
 struct GenericArrays : rfl::Processors<> {};
 
+template <class R, class W, class T, std::size_t N, class Ps>
+struct GenericArrayParser : rfl::parsing::ParserArray<R, W, T, N, Ps> {
+  static rfl::Result<std::array<T, N>> read(
+      const R& reader, const typename R::InputVarType& var) noexcept {
+    if constexpr (std::is_arithmetic_v<T>) {
+      // Keep the generic element reader, but give GCC initialized storage.
+      // GCC 13 reports -Wmaybe-uninitialized for the generic parser's raw
+      // placement-new buffer when these tests instantiate one-element arrays.
+      std::array<T, N> values{};
+      const rfl::parsing::ArrayReader<R, W, Ps, T, N> elements(&reader,
+                                                               &values);
+      if (const auto err = reader.template read_fixed_array<N>(elements, var)) {
+        return rfl::error(*err);
+      }
+      if (const auto err = elements.check_size()) {
+        return rfl::error(*err);
+      }
+      return values;
+    } else {
+      return rfl::parsing::ParserArray<R, W, T, N, Ps>::read(reader, var);
+    }
+  }
+};
+
 struct Nested {
   std::array<double, 3> values;
   std::array<double, 0> empty;
@@ -49,11 +75,14 @@ void check_compatible(const T& input, Write write, Read read,
   EXPECT_EQ(write(*decoded), generic);
 }
 
-template <class T, class Check, class Write, class Read, class GenericWrite>
+template <class T, bool CheckSingleBool = true, class Check, class Write,
+          class Read, class GenericWrite>
 void check_type(Check check, Write write, Read read,
                 GenericWrite generic_write) {
   check(std::array<T, 0>{});
-  check(std::array<T, 1>{T(1)});
+  if constexpr (CheckSingleBool || !std::is_same_v<T, bool>) {
+    check(std::array<T, 1>{T(1)});
+  }
   check(std::array<T, 4>{std::numeric_limits<T>::lowest(), T(0), T(1),
                          std::numeric_limits<T>::max()});
   std::array<T, 65> many{};
@@ -73,14 +102,15 @@ void check_type(Check check, Write write, Read read,
   }
 }
 
-template <class Write, class Read, class GenericWrite, class GenericRead>
+template <bool CheckSingleBool = true, class Write, class Read,
+          class GenericWrite, class GenericRead>
 void check_types(Write write, Read read, GenericWrite generic_write,
                  GenericRead generic_read) {
   const auto check = [&](const auto& input) {
     check_compatible(input, write, read, generic_write, generic_read);
   };
   [&]<class... Ts>(std::tuple<Ts...>*) {
-    (check_type<Ts>(check, write, read, generic_write), ...);
+    (check_type<Ts, CheckSingleBool>(check, write, read, generic_write), ...);
   }(static_cast<std::tuple<
         std::int8_t, std::uint8_t, std::int16_t, std::uint16_t, std::int32_t,
         std::uint32_t, std::int64_t, std::uint64_t, float, double, bool, char,
diff --git a/tests/yas/test_numeric_array_io.cpp b/tests/yas/test_numeric_array_io.cpp
index e054b4d39..0127e9fb9 100644
--- a/tests/yas/test_numeric_array_io.cpp
+++ b/tests/yas/test_numeric_array_io.cpp
@@ -8,8 +8,9 @@ namespace rfl::parsing {
 template <class T, std::size_t N, class... Ps>
 struct Parser<yas::Reader, yas::Writer, std::array<T, N>,
               Processors<test_numeric_array_io::GenericArrays, Ps...>>
-    : ParserArray<yas::Reader, yas::Writer, T, N,
-                  Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
+    : test_numeric_array_io::GenericArrayParser<
+          yas::Reader, yas::Writer, T, N,
+          Processors<test_numeric_array_io::GenericArrays, Ps...>> {};
 }  // namespace rfl::parsing
 
 namespace test_numeric_array_io {