From 2770cb53424584db8c4c19aabef051ff3148f558 Mon Sep 17 00:00:00 2001
From: Manasvi Goyal <mg.manasvi@gmail.com>
Date: Fri, 20 Oct 2023 11:49:45 +0200
Subject: [PATCH 1/3] Add a test for ctypes for fake case

---
 src-fake-test/BuilderOptions.h        |   66 +
 src-fake-test/GrowableBuffer.h        |  564 +++++++
 src-fake-test/LayoutBuilder.h         | 2238 +++++++++++++++++++++++++
 src-fake-test/fake.cpp                |  149 ++
 src-fake-test/fake.h                  |  187 +++
 src-fake-test/fake.py                 |   77 +
 src-fake-test/fake.raw                |  Bin 0 -> 36000 bytes
 src-fake-test/kaitai/custom_decoder.h |   16 +
 src-fake-test/kaitai/exceptions.h     |  224 +++
 src-fake-test/kaitai/kaitaistream.cpp |  877 ++++++++++
 src-fake-test/kaitai/kaitaistream.h   |  374 +++++
 src-fake-test/kaitai/kaitaistruct.h   |   20 +
 src-fake-test/utils.h                 |  275 +++
 13 files changed, 5067 insertions(+)
 create mode 100644 src-fake-test/BuilderOptions.h
 create mode 100644 src-fake-test/GrowableBuffer.h
 create mode 100644 src-fake-test/LayoutBuilder.h
 create mode 100644 src-fake-test/fake.cpp
 create mode 100644 src-fake-test/fake.h
 create mode 100644 src-fake-test/fake.py
 create mode 100644 src-fake-test/fake.raw
 create mode 100644 src-fake-test/kaitai/custom_decoder.h
 create mode 100644 src-fake-test/kaitai/exceptions.h
 create mode 100644 src-fake-test/kaitai/kaitaistream.cpp
 create mode 100644 src-fake-test/kaitai/kaitaistream.h
 create mode 100644 src-fake-test/kaitai/kaitaistruct.h
 create mode 100644 src-fake-test/utils.h

diff --git a/src-fake-test/BuilderOptions.h b/src-fake-test/BuilderOptions.h
new file mode 100644
index 0000000..036aa0c
--- /dev/null
+++ b/src-fake-test/BuilderOptions.h
@@ -0,0 +1,66 @@
+// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+#ifndef AWKWARD_BUILDEROPTIONS_H_
+#define AWKWARD_BUILDEROPTIONS_H_
+
+#include <cassert>
+#include <cstring>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+#include <stdint.h>
+
+namespace awkward {
+
+  /// @class Options
+  ///
+  /// @brief Container for all configuration options needed by ArrayBuilder,
+  /// GrowableBuffer, LayoutBuilder and the Builder subclasses.
+  template <typename... OPTIONS>
+  struct Options {
+    static constexpr std::size_t value = sizeof...(OPTIONS);
+
+    using OptionsPack = typename std::tuple<OPTIONS...>;
+
+    // FIXME:
+    // std::tuple_element_t is missing on some of the CI node compilers
+    //
+    // template<std::size_t INDEX>
+    // using OptionType = std::tuple_element_t<INDEX, OptionsPack>;
+
+    template <std::size_t INDEX>
+    using OptionType =
+        typename std::tuple_element<INDEX, decltype(OptionsPack())>::type;
+
+    /// @brief Creates an Options tuple from a full set of parameters.
+    Options(OPTIONS... options) : pars(options...) {}
+
+    /// @brief The initial number of
+    /// {@link GrowableBuffer#reserved reserved} entries for a GrowableBuffer.
+    int64_t
+    initial() const noexcept {
+      return option<0>();
+    }
+
+    /// @brief The factor with which a GrowableBuffer is resized
+    /// when its {@link GrowableBuffer#length length} reaches its
+    /// {@link GrowableBuffer#reserved reserved}.
+    double
+    resize() const noexcept {
+      return option<1>();
+    }
+
+    /// @brief Access to all other options.
+    template <std::size_t INDEX>
+    const OptionType<INDEX>&
+    option() const noexcept {
+      return std::get<INDEX>(pars);
+    }
+
+    OptionsPack pars;
+  };
+
+  using BuilderOptions = Options<int64_t, double>;
+}  // namespace awkward
+
+#endif  // AWKWARD_BUILDEROPTIONS_H_
diff --git a/src-fake-test/GrowableBuffer.h b/src-fake-test/GrowableBuffer.h
new file mode 100644
index 0000000..6d5b7b8
--- /dev/null
+++ b/src-fake-test/GrowableBuffer.h
@@ -0,0 +1,564 @@
+// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+#ifndef AWKWARD_GROWABLEBUFFER_H_
+#define AWKWARD_GROWABLEBUFFER_H_
+
+#include "BuilderOptions.h"
+
+#include <cstring>
+#include <vector>
+#include <memory>
+#include <numeric>
+#include <cmath>
+#include <complex>
+#include <iostream>
+#include <utility>
+#include <stdexcept>
+#include <stdint.h>
+
+namespace awkward {
+
+  template <template <class...> class TT, class... Args>
+  std::true_type is_tt_impl(TT<Args...>);
+  template <template <class...> class TT>
+  std::false_type is_tt_impl(...);
+
+  template <template <class...> class TT, class T>
+  using is_tt = decltype(is_tt_impl<TT>(std::declval<typename std::decay<T>::type>()));
+
+  template <typename PRIMITIVE>
+  /// @class Panel
+  ///
+  /// Creates a contiguous, one-dimensional panel.
+  class Panel {
+  public:
+
+    /// @brief Creates a Panel by allocating a new panel, taking a
+    /// #reserved number of slots.
+    ///
+    /// @param reserved Currently allocated number of elements in the panel.
+    Panel(size_t reserved)
+        : ptr_(std::unique_ptr<PRIMITIVE[]>(new PRIMITIVE[reserved])),
+          length_(0),
+          reserved_(reserved),
+          next_(nullptr) {}
+
+    /// @brief Creates a Panel from a full set of parameters.
+    ///
+    /// @param ptr Unique reference to the panel data.
+    /// @param length Currently number used of elements in the panel.
+    /// @param reserved Currently allocated number of elements in the panel.
+    Panel(std::unique_ptr<PRIMITIVE[]> ptr, size_t length, size_t reserved)
+        : ptr_(std::move(ptr)),
+          length_(length),
+          reserved_(reserved),
+          next_(nullptr) {}
+
+    /// @brief Deletes a Panel.
+    ///
+    /// Unchain the pointers to avoid a stack overflow when
+    /// a recursive implicit destructor is invoked.
+    ~Panel() {
+      for (std::unique_ptr<Panel> current = std::move(next_);
+           current;
+           current = std::move(current->next_));
+    }
+
+    /// @brief Overloads [] operator to access elements like an array.
+    PRIMITIVE& operator[](size_t i) { return ptr_.get()[i]; }
+
+    /// @brief Creates a new panel with slots equal to #reserved and
+    /// appends it after the current panel.
+    Panel*
+    append_panel(size_t reserved) {
+      next_ = std::move(std::unique_ptr<Panel>(new Panel(reserved)));
+      return next_.get();
+    }
+
+    /// @brief Inserts one `datum` into the panel.
+    void
+    fill_panel(PRIMITIVE datum) {
+      ptr_.get()[length_++] = datum;
+    }
+
+    /// @brief Pointer to the next panel.
+    std::unique_ptr<Panel>&
+    next() {
+      return next_;
+    }
+
+    /// @brief Currently used number of elements in the panel.
+    size_t
+    current_length() {
+      return length_;
+    }
+
+    /// @brief Currently allocated number of elements in the panel.
+    size_t
+    reserved() {
+      return reserved_;
+    }
+
+    /// @brief Unique pointer to the panel data.
+    std::unique_ptr<PRIMITIVE[]>&
+    data() {
+      return ptr_;
+    }
+
+    /// @brief Copies the data from a panel to one contiguously allocated `to_ptr`.
+    ///
+    /// @param to_ptr One contiguously allocated panel.
+    /// @param offset Distance between `to_ptr` and the pointer to the destination where the
+    /// accumulated data is copied.
+    /// @param from Distance between `ptr` and pointer to the source of the data to be copied.
+    /// @param length Length of the data to be copied.
+    void
+    append(PRIMITIVE* to_ptr, size_t offset, size_t from, int64_t length) const noexcept {
+      memcpy(to_ptr + offset,
+             reinterpret_cast<void*>(ptr_.get() + from),
+             length * sizeof(PRIMITIVE) - from);
+    }
+
+    /// @brief Copies and concatenates the accumulated data from multiple panels `ptr_` to one
+    /// contiguously allocated `to_ptr`.
+    ///
+    /// @param to_ptr One contiguously allocated panel.
+    /// @param offset Distance between `to_ptr` and the pointer to the destination where the
+    /// accumulated data is copied.
+    /// @param from Distance between `ptr` and pointer to the source of the data to be copied.
+    void
+    concatenate_to_from(PRIMITIVE* to_ptr, size_t offset, size_t from) const noexcept {
+      memcpy(to_ptr + offset,
+             reinterpret_cast<void*>(ptr_.get() + from),
+             length_ * sizeof(PRIMITIVE) - from);
+      if (next_) {
+        next_->concatenate_to(to_ptr, offset + length_);
+      }
+    }
+
+    /// @brief Copies and concatenates the accumulated data from multiple panels `ptr_` to one
+    /// contiguously allocated `to_ptr`.
+    ///
+    /// @param to_ptr One contiguously allocated panel.
+    /// @param offset Distance between `to_ptr` and the pointer to the destination where the
+    /// accumulated data is copied.
+    void
+    concatenate_to(PRIMITIVE* to_ptr, size_t offset) const noexcept {
+      memcpy(to_ptr + offset,
+             reinterpret_cast<void*>(ptr_.get()),
+             length_ * sizeof(PRIMITIVE));
+      if (next_) {
+        next_->concatenate_to(to_ptr, offset + length_);
+      }
+      for(int i = 0; i < 10; i++)
+        std::cout << ptr_[i] << "  ";
+    }
+
+    /// @brief Fills (one panel) GrowableBuffer<TO_PRIMITIVE> with the
+    /// elements of (possibly multi-panels) GrowableBuffer<PRIMITIVE>.
+    ///
+    /// Changes the data type from `PRIMITIVE` to `TO_PRIMITIVE`/
+    template <typename TO_PRIMITIVE>
+    typename std::enable_if<(!awkward::is_tt<std::complex, TO_PRIMITIVE>::value &&
+                             !awkward::is_tt<std::complex, PRIMITIVE>::value) ||
+                            (awkward::is_tt<std::complex, TO_PRIMITIVE>::value &&
+                             awkward::is_tt<std::complex, PRIMITIVE>::value)>::type
+    copy_as(TO_PRIMITIVE* to_ptr, size_t offset) {
+      for (size_t i = 0; i < length_; i++) {
+        to_ptr[offset++] = static_cast<TO_PRIMITIVE>(ptr_.get()[i]);
+      }
+      if (next_) {
+        next_->copy_as(to_ptr, offset);
+      }
+    }
+
+    template <typename TO_PRIMITIVE>
+    typename std::enable_if<!awkward::is_tt<std::complex, TO_PRIMITIVE>::value &&
+                             awkward::is_tt<std::complex, PRIMITIVE>::value>::type
+    copy_as(TO_PRIMITIVE* to_ptr, size_t offset) {
+      for (size_t i = 0; i < length_; i++) {
+        to_ptr[offset++] = static_cast<TO_PRIMITIVE>(ptr_.get()[i].real());
+        to_ptr[offset++] = static_cast<TO_PRIMITIVE>(ptr_.get()[i].imag());
+      }
+      if (next_) {
+        next_->copy_as(to_ptr, offset);
+      }
+    }
+
+    /// @brief 'copy_as' specialization of a 'std::complex' template type.
+    /// Fills (one panel) GrowableBuffer<std::complex> with the
+    /// elements of (possibly multi-panels) GrowableBuffer<PRIMITIVE>.
+    ///
+    /// Changes the data type from `PRIMITIVE` to `std::complex`/
+    template <typename TO_PRIMITIVE>
+    typename std::enable_if<awkward::is_tt<std::complex, TO_PRIMITIVE>::value &&
+                            !awkward::is_tt<std::complex, PRIMITIVE>::value>::type
+    copy_as(TO_PRIMITIVE* to_ptr, size_t offset) {
+      for (size_t i = 0; i < length_; i++) {
+        double val = static_cast<double>(ptr_.get()[i]);
+        to_ptr[offset++] = TO_PRIMITIVE(val);
+      }
+      if (next_) {
+        next_->copy_as(to_ptr, offset);
+      }
+    }
+
+  private:
+    /// @brief Unique pointer to the panel data.
+    std::unique_ptr<PRIMITIVE[]> ptr_;
+
+    /// @brief The length of the panel data.
+    size_t length_;
+
+    /// @brief Reserved size of the panel.
+    size_t reserved_;
+
+    /// @brief Pointer to the next Panel.
+    std::unique_ptr<Panel> next_;
+  };
+
+  /// @class GrowableBuffer
+  ///
+  /// @brief Discontiguous, one-dimensional buffer (which consists of
+  /// multiple contiguous, one-dimensional panels) that can grow
+  /// indefinitely by calling #append.
+  ///
+  /// Configured by BuilderOptions, the buffer starts by reserving
+  /// {@link BuilderOptions#initial initial} slots.
+  /// When the number of slots used reaches the number reserved, a new
+  /// panel is allocated that is
+  /// {@link BuilderOptions#resize resize} times larger.
+  ///
+  /// When {@link ArrayBuilder#to_buffers ArrayBuilder::to_buffers} is called,
+  /// these buffers are copied to the new Content array.
+  template <typename PRIMITIVE>
+  class GrowableBuffer {
+  public:
+    /// @brief Creates an empty GrowableBuffer.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    static GrowableBuffer<PRIMITIVE>
+    empty(const BuilderOptions& options) {
+      return empty(options, 0);
+    }
+
+    /// @brief Creates an empty GrowableBuffer with a minimum reservation.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    /// @param minreserve The initial reservation will be the maximum
+    /// of `minreserve` and
+    /// {@link BuilderOptions#initial initial}.
+    static GrowableBuffer<PRIMITIVE>
+    empty(const BuilderOptions& options, int64_t minreserve) {
+      int64_t actual = options.initial();
+      if (actual < minreserve) {
+        actual = minreserve;
+      }
+      return GrowableBuffer(
+          options,
+          std::unique_ptr<PRIMITIVE[]>(new PRIMITIVE[(size_t)actual]),
+          0,
+          actual);
+    }
+
+    /// @brief Creates a GrowableBuffer in which all elements are initialized to `0`.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    /// @param length The number of elements to initialize (and the
+    /// GrowableBuffer's initial #length).
+    ///
+    /// This is similar to NumPy's
+    /// [zeros](https://docs.scipy.org/doc/numpy/reference/generated/numpy.zeros.html).
+    static GrowableBuffer<PRIMITIVE>
+    zeros(const BuilderOptions& options, int64_t length) {
+      int64_t actual = options.initial();
+      if (actual < length) {
+        actual = length;
+      }
+      auto ptr = std::unique_ptr<PRIMITIVE[]>(new PRIMITIVE[(size_t)actual]);
+      PRIMITIVE* rawptr = ptr.get();
+      for (int64_t i = 0; i < length; i++) {
+        rawptr[i] = 0;
+      }
+      return GrowableBuffer(options, std::move(ptr), length, actual);
+    }
+
+    /// @brief Creates a GrowableBuffer in which all elements are initialized
+    /// to a given value.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    /// @param value The initialization value.
+    /// @param length The number of elements to initialize (and the
+    /// GrowableBuffer's initial #length).
+    ///
+    /// This is similar to NumPy's
+    /// [full](https://docs.scipy.org/doc/numpy/reference/generated/numpy.full.html).
+    static GrowableBuffer<PRIMITIVE>
+    full(const BuilderOptions& options, PRIMITIVE value, int64_t length) {
+      int64_t actual = options.initial();
+      if (actual < length) {
+        actual = length;
+      }
+      auto ptr = std::unique_ptr<PRIMITIVE[]>(new PRIMITIVE[(size_t)actual]);
+      PRIMITIVE* rawptr = ptr.get();
+      for (int64_t i = 0; i < length; i++) {
+        rawptr[i] = value;
+      }
+      return GrowableBuffer<PRIMITIVE>(options, std::move(ptr), length, actual);
+    }
+
+    /// @brief Creates a GrowableBuffer in which the elements are initialized
+    /// to numbers counting from `0` to `length`.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    /// @param length The number of elements to initialize (and the
+    /// GrowableBuffer's initial #length).
+    ///
+    /// This is similar to NumPy's
+    /// [arange](https://docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html).
+    static GrowableBuffer<PRIMITIVE>
+    arange(const BuilderOptions& options, int64_t length) {
+      int64_t actual = options.initial();
+      if (actual < length) {
+        actual = length;
+      }
+      auto ptr = std::unique_ptr<PRIMITIVE[]>(new PRIMITIVE[(size_t)actual]);
+      PRIMITIVE* rawptr = ptr.get();
+      for (int64_t i = 0; i < length; i++) {
+        rawptr[i] = (PRIMITIVE)i;
+      }
+      return GrowableBuffer(options, std::move(ptr), length, actual);
+    }
+
+    /// @brief Takes a (possibly multi-panels) GrowableBuffer<PRIMITIVE>
+    /// and makes another (one panel) GrowableBuffer<TO_PRIMITIVE>.
+    ///
+    /// Used to change the data type of buffer content from `PRIMITIVE`
+    /// to `TO_PRIMITIVE` for building arrays.
+    template <typename TO_PRIMITIVE>
+    static GrowableBuffer<TO_PRIMITIVE>
+    copy_as(const GrowableBuffer<PRIMITIVE>& other) {
+      int64_t len = (int64_t)other.length();
+      int64_t actual =
+          (len < other.options_.initial()) ? other.options_.initial() : len;
+
+      if (!awkward::is_tt<std::complex, TO_PRIMITIVE>::value &&
+        awkward::is_tt<std::complex, PRIMITIVE>::value) {
+          len *= 2;
+          actual *= 2;
+        }
+
+      auto ptr =
+          std::unique_ptr<TO_PRIMITIVE[]>(new TO_PRIMITIVE[(size_t)actual]);
+      TO_PRIMITIVE* rawptr = ptr.get();
+
+      other.panel_->copy_as(rawptr, 0);
+
+      return GrowableBuffer<TO_PRIMITIVE>(
+          BuilderOptions(actual, other.options().resize()),
+          std::move(ptr),
+          len,
+          actual);
+    }
+
+    /// @brief Creates a GrowableBuffer from a full set of parameters.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    /// @param ptr Reference-counted pointer to the array buffer.
+    /// @param length Currently used number of elements.
+    /// @param reserved Currently allocated number of elements.
+    ///
+    /// Although the #length increments every time #append is called,
+    /// it is always less than or equal to #reserved because of
+    /// allocations of new panels.
+    GrowableBuffer(const BuilderOptions& options,
+                   std::unique_ptr<PRIMITIVE[]> ptr,
+                   int64_t length,
+                   int64_t reserved)
+        : options_(options),
+          length_(0),
+          panel_(std::unique_ptr<Panel<PRIMITIVE>>(new Panel<PRIMITIVE>(
+              std::move(ptr), (size_t)length, (size_t)reserved))),
+          ptr_(panel_.get()) {}
+
+    /// @brief Creates a GrowableBuffer by allocating a new buffer, taking an
+    /// options #reserved from #options.
+    ///
+    /// @param options Initial size configuration for building a panel.
+    GrowableBuffer(const BuilderOptions& options)
+        : GrowableBuffer(options,
+                         std::unique_ptr<PRIMITIVE[]>(
+                             new PRIMITIVE[(size_t)options.initial()]),
+                         0,
+                         options.initial()) {}
+
+    /// @brief Move constructor
+    ///
+    /// panel_ is move-only.
+    GrowableBuffer(GrowableBuffer&& other) noexcept
+        : options_(other.options_),
+          length_(other.length_),
+          panel_(std::move(other.panel_)),
+          ptr_(other.ptr_) {}
+
+    /// @brief Currently used number of elements.
+    ///
+    /// Although the #length increments every time #append is called,
+    /// it is always less than or equal to #reserved because of
+    /// allocations of new panels.
+    size_t
+    length() const {
+      return length_ + ptr_->current_length();
+    }
+
+    /// @brief Return options of this GrowableBuffer.
+    const BuilderOptions&
+    options() const {
+      return options_;
+    }
+
+    /// @brief Discards accumulated data, the #reserved returns to
+    /// options.initial(), and a new #ptr is allocated.
+    void
+    clear() {
+      panel_ = std::move(std::unique_ptr<Panel<PRIMITIVE>>(
+          new Panel<PRIMITIVE>((size_t)options_.initial())));
+      ptr_ = panel_.get();
+      length_ = 0;
+    }
+
+    /// @brief Last element in last panel
+    PRIMITIVE
+    last() const {
+      if (ptr_->current_length() == 0) {
+        throw std::runtime_error("Buffer is empty");
+      } else {
+        return (*ptr_)[ptr_->current_length() - 1];
+      }
+    }
+
+    /// @brief Currently used number of bytes.
+    size_t
+    nbytes() const {
+      return length() * sizeof(PRIMITIVE);
+    }
+
+    /// @brief Inserts one `datum` into the panel, possibly triggering
+    /// allocation of a new panel.
+    ///
+    /// This increases the #length by 1; if the new #length is larger than
+    /// #reserved, a new panel will be allocated.
+    void
+    append(PRIMITIVE datum) {
+      if (ptr_->current_length() == ptr_->reserved()) {
+        add_panel((size_t)ceil(options_.initial() * options_.resize()));
+      }
+      fill_panel(datum);
+    }
+
+    /// @brief Inserts an entire array into the panel(s), possibly triggering
+    /// allocation of a new panel.
+    ///
+    /// If the size is larger than the empty slots in the current panel, then,
+    /// first, the empty slots are filled and then a new panel will be allocated
+    /// for the rest of the array elements.
+    void
+    extend(const PRIMITIVE* ptr, size_t size) {
+      size_t unfilled_items = ptr_->reserved() - ptr_->current_length();
+      if (size > unfilled_items) {
+        for (size_t i = 0; i < unfilled_items; i++) {
+          fill_panel(ptr[i]);
+        }
+        add_panel(size - unfilled_items > ptr_->reserved() ? size - unfilled_items
+                                                        : ptr_->reserved());
+        for (size_t i = unfilled_items; i < size; i++) {
+          fill_panel(ptr[i]);
+        }
+      } else {
+        for (size_t i = 0; i < size; i++) {
+          fill_panel(ptr[i]);
+        }
+      }
+    }
+
+    /// @brief Like append, but the type signature returns the reference to `PRIMITIVE`.
+    PRIMITIVE&
+    append_and_get_ref(PRIMITIVE datum) {
+      append(datum);
+      return (*ptr_)[ptr_->current_length() - 1];
+    }
+
+    /// @brief Copies and concatenates all accumulated data from multiple panels to one
+    /// contiguously allocated `external_pointer`.
+    void
+    concatenate(PRIMITIVE* external_pointer) const noexcept {
+      if (external_pointer) {
+        panel_->concatenate_to(external_pointer, 0);
+      }
+    }
+
+    /// @brief Moves all accumulated data from multiple panels to one
+    /// contiguously allocated `external_pointer`. The panels are deleted,
+    /// and a new #ptr is allocated.
+    void
+    move_to(PRIMITIVE* to_ptr) noexcept {
+      size_t next_offset = 0;
+      while(panel_) {
+        memcpy(to_ptr + next_offset,
+               reinterpret_cast<void*>(panel_.get()->data().get()),
+               panel_.get()->current_length() * sizeof(PRIMITIVE));
+        next_offset += panel_.get()->current_length();
+        panel_ = std::move(panel_.get()->next());
+      }
+      clear();
+    }
+
+    /// @brief Copies and concatenates all accumulated data from multiple panels to one
+    /// contiguously allocated `external_pointer`.
+    void
+    concatenate_from(PRIMITIVE* external_pointer, size_t to, size_t from) const noexcept {
+      if (external_pointer) {
+        panel_->concatenate_to_from(external_pointer, to, from);
+      }
+    }
+
+    /// @brief Copies data from a panel to one contiguously allocated `external_pointer`.
+    void
+    append(PRIMITIVE* external_pointer, size_t offset, size_t from, int64_t length) const noexcept {
+      if (external_pointer) {
+        panel_->append(external_pointer, offset, from, length);
+      }
+    }
+
+  private:
+    /// @brief Fills the data into the panel one by one.
+    void
+    fill_panel(PRIMITIVE datum) {
+      ptr_->fill_panel(datum);
+    }
+
+    /// @brief Adds a new panel with slots equal to #reserved.
+    /// and updates the current panel pointer to it.
+    void
+    add_panel(size_t reserved) {
+      length_ += ptr_->current_length();
+      ptr_ = ptr_->append_panel(reserved);
+    }
+
+    /// @brief Initial size configuration for building a panel.
+    const BuilderOptions options_;
+
+    /// @brief Filled panels data length.
+    size_t length_;
+
+    /// @brief The first panel.
+    std::unique_ptr<Panel<PRIMITIVE>> panel_;
+
+    /// @brief A pointer to a current panel.
+    ///
+    /// Points to the address of the first byte of the current panel.
+    Panel<PRIMITIVE>* ptr_;
+  };
+}  // namespace awkward
+
+#endif  // AWKWARD_GROWABLEBUFFER_H_
diff --git a/src-fake-test/LayoutBuilder.h b/src-fake-test/LayoutBuilder.h
new file mode 100644
index 0000000..e80086d
--- /dev/null
+++ b/src-fake-test/LayoutBuilder.h
@@ -0,0 +1,2238 @@
+// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+#ifndef AWKWARD_LAYOUTBUILDER_H_
+#define AWKWARD_LAYOUTBUILDER_H_
+
+#include "BuilderOptions.h"
+#include "GrowableBuffer.h"
+#include "utils.h"
+
+#include <map>
+#include <algorithm>
+#include <tuple>
+#include <string>
+#include <functional>
+
+/// @brief Object of {@link BuilderOptions BuilderOptions} which sets the
+/// values of the default options.
+#define AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS awkward::BuilderOptions(1024, 1)
+
+namespace {
+
+template <class NODE, class PRIMITIVE, class LENGTH>
+void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length) {
+  out << node << ": ";
+  for (size_t i = 0; i < length; i++) {
+    out << +ptr[i] << " ";
+  }
+  out << std::endl;
+}
+
+template<class NODE, class PRIMITIVE, class LENGTH, class ... Args>
+void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length, Args&&...args)
+{
+    dump(out, node, ptr, length);
+    dump(out, args...);
+}
+
+std::map<std::string, void*>
+inline empty_buffers(std::map<std::string, size_t> &names_nbytes) {
+  std::map<std::string, void*> buffers = {};
+  for(const auto& it : names_nbytes) {
+    auto* ptr = new uint8_t[it.second];
+    buffers[it.first] = (void*)ptr;
+  }
+  return buffers;
+}
+
+  /// @brief Helper function to retrieve the buffers.
+  template<typename LayoutBuilder>
+  std::vector<uint8_t*> to_buffer_helper(const LayoutBuilder* builder) {
+    std::map <std::string, size_t> names_nbytes = {};
+    std::vector <uint8_t*> buffer_array;
+    builder->buffer_nbytes(names_nbytes);
+
+    std::map<std::string, void *> buffers = {};
+    for (auto it: names_nbytes) {
+        uint8_t *ptr = new uint8_t[it.second];
+        buffers[it.first] = (void *) ptr;
+    }
+
+    builder->to_buffers(buffers);
+
+    for (auto it: buffers) {
+      buffer_array.push_back(reinterpret_cast<uint8_t*>(it.second));
+    }
+    return buffer_array;
+  }
+
+  /// @brief Helper function to retrieve the names of the buffers.
+  template<typename LayoutBuilder>
+  std::vector<std::string> buffer_name_helper(const LayoutBuilder* builder) {
+    std::map <std::string, size_t> names_nbytes = {};
+    std::vector<std::string> buffer_name;
+    builder->buffer_nbytes(names_nbytes);
+    for (auto it: names_nbytes) {
+      buffer_name.push_back(it.first);
+    }
+    return buffer_name;
+  }
+
+  /// @brief Helper function to retrieve the sizes (in bytes) of the buffers.
+  template<typename LayoutBuilder>
+  std::vector<size_t> buffer_size_helper(const LayoutBuilder* builder) {
+    std::map <std::string, size_t> names_nbytes = {};
+    std::vector<size_t> buffer_size;
+    builder->buffer_nbytes(names_nbytes);
+    for (auto it: names_nbytes) {
+      buffer_size.push_back(it.second);
+    }
+    return buffer_size;
+  }
+
+  /// @brief Helper function to retrieve the number of the buffers.
+  template<typename LayoutBuilder>
+  size_t num_buffers_helper(const LayoutBuilder* builder) {
+    std::map <std::string, size_t> names_nbytes = {};
+    builder->buffer_nbytes(names_nbytes);
+    return names_nbytes.size();
+  }
+}
+
+namespace awkward {
+
+  namespace LayoutBuilder {
+
+    /// @class Field
+    ///
+    /// @brief Helper class for sending a pair of field names (as enum) and field
+    /// type as template parameters in {@link Record Record}.
+    ///
+    /// @tparam ENUM Enumerated type which assigns index values to field names.
+    /// @tparam BUILDER The type of field.
+    template <std::size_t ENUM, typename BUILDER>
+    class Field {
+    public:
+      using Builder = BUILDER;
+
+      /// @brief Converts index as field string.
+      std::string
+      index_as_field() const {
+        return std::to_string(index);
+      }
+
+      /// @brief The index of a Record field.
+      const std::size_t index = ENUM;
+      /// @brief The content type of field in a Record.
+      Builder builder;
+    };
+
+    /// @class Numpy
+    ///
+    /// @brief Builds a NumpyArray which describes multi-dimensional data
+    /// of `PRIMITIVE` type.
+    ///
+    /// @tparam PRIMITIVE The type of data in NumpyArray.
+    template <typename PRIMITIVE>
+    class Numpy {
+    public:
+      /// @brief Creates a new Numpy layout builder by allocating a new buffer,
+      /// using `AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS` for initializing the buffer.
+      Numpy()
+          : data_(
+                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Creates a new Numpy layout builder by allocating a new buffer,
+      /// taking `options` from {@link BuilderOptions BuilderOptions}
+      /// for initializing the buffer.
+      ///
+      /// @param options Initial size configuration of a buffer.
+      Numpy(const awkward::BuilderOptions& options)
+          : data_(awkward::GrowableBuffer<PRIMITIVE>(options)) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Inserts a `PRIMITIVE` type data.
+      void
+      append(PRIMITIVE x) noexcept {
+        data_.append(x);
+      }
+
+      /// @brief Inserts an entire array of `PRIMITIVE` type data.
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      void
+      extend(PRIMITIVE* ptr, size_t size) noexcept {
+        data_.extend(ptr, size);
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+      }
+
+      /// @brief Discards the accumulated data in the builder.
+      void
+      clear() noexcept {
+        data_.clear();
+      }
+
+      /// @brief Current length of the data.
+      size_t
+      length() const noexcept {
+        return data_.length();
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& /* error */) const noexcept {
+        return true;
+      }
+
+      /// @brief Retrieves the name and size (in bytes) of the buffer.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        names_nbytes["node" + std::to_string(id_) + "-data"] = data_.nbytes();
+
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a user-defined pointer.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same name and size (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        data_.concatenate(reinterpret_cast<PRIMITIVE*>(
+            buffers["node" + std::to_string(id_) + "-data"]));
+        }
+
+      void
+      to_buffer(void* buffer, const char* name) const noexcept {
+        if (std::string(name) == std::string("node" + std::to_string(id_) + "-data"))
+          data_.concatenate(reinterpret_cast<PRIMITIVE*>(buffer));
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        data_.concatenate(reinterpret_cast<PRIMITIVE*>(
+          buffers["node" + std::to_string(id_) + "-data"]));
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+
+        if (std::is_arithmetic<PRIMITIVE>::value) {
+          return "{ \"class\": \"NumpyArray\", \"primitive\": \"" +
+                 type_to_name<PRIMITIVE>() + "\"" + params +
+                 ", \"form_key\": \"" + form_key.str() + "\" }";
+        } else if (is_specialization<PRIMITIVE, std::complex>::value) {
+          return "{ \"class\": \"NumpyArray\", \"primitive\": \"" +
+                 type_to_name<PRIMITIVE>() + "\"" + params +
+                 ", \"form_key\": \"" + form_key.str() + "\" }";
+        } else {
+          throw std::runtime_error("type " +
+                                   std::string(typeid(PRIMITIVE).name()) +
+                                   "is not supported");
+        }
+      }
+
+    // private:
+      /// @brief Buffer of `PRIMITIVE` type.
+      awkward::GrowableBuffer<PRIMITIVE> data_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+    };
+
+    /// @class ListOffset
+    ///
+    /// @brief Builds a ListOffsetArray which describes unequal-length lists
+    /// (often called a "jagged" or "ragged" array). The underlying data for
+    /// all lists are in a BUILDER content. It is subdivided into lists according
+    /// to an offsets array, which specifies the starting and stopping index of each list.
+    ///
+    /// The offsets must have at least length `1` (corresponding to an empty array).
+    ///
+    /// The offsets values can be 64-bit signed integers `int64`, 32-bit signed integers
+    /// `int32` or 32-bit unsigned integers `uint32`.
+    ///
+    /// @tparam PRIMITIVE The type of `offsets` buffer.
+    /// @tparam BUILDER The type of builder content.
+    template <typename PRIMITIVE, typename BUILDER>
+    class ListOffset {
+    public:
+      /// @brief Creates a new ListOffset layout builder by allocating a new `offset`
+      ///  buffer, using `AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS` for initializing the buffer.
+      ListOffset()
+          : offsets_(
+                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
+        offsets_.append(0);
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Creates a new ListOffset layout builder by allocating a new `offset`
+      /// buffer, taking `options` from {@link BuilderOptions BuilderOptions} for
+      /// initializing the buffer.
+      ///
+      /// @param options Initial size configuration of a buffer.
+      ListOffset(const awkward::BuilderOptions& options)
+          : offsets_(awkward::GrowableBuffer<PRIMITIVE>(options)) {
+        offsets_.append(0);
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns the reference to the builder content.
+      BUILDER&
+      content() noexcept {
+        return content_;
+      }
+
+      /// @brief Begins a list and returns the reference to the builder content.
+      BUILDER&
+      begin_list() noexcept {
+        return content_;
+      }
+
+      /// @brief Ends a list and appends the current length of the list
+      /// contents in the `offsets` buffer.
+      void
+      end_list() noexcept {
+        offsets_.append(content_.length());
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        content_.set_id(id);
+      }
+
+      /// @brief Discards the accumulated offsets and clears the builder content.
+      void
+      clear() noexcept {
+        offsets_.clear();
+        offsets_.append(0);
+        content_.clear();
+      }
+
+      /// @brief Current length of the content.
+      size_t
+      length() const noexcept {
+        return offsets_.length() - 1;
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        if ((int64_t)content_.length() != (int64_t)offsets_.last()) {
+          std::stringstream out;
+          out << "ListOffset node" << id_ << "has content length "
+              << content_.length() << "but last offset " << offsets_.last()
+              << "\n";
+          error.append(out.str());
+
+          return false;
+        } else {
+          return content_.is_valid(error);
+        }
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        names_nbytes["node" + std::to_string(id_) + "-offsets"] =
+            offsets_.nbytes();
+        content_.buffer_nbytes(names_nbytes);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        offsets_.concatenate(reinterpret_cast<PRIMITIVE*>(
+            buffers["node" + std::to_string(id_) + "-offsets"]));
+        content_.to_buffers(buffers);
+      }
+
+      void
+      to_buffer(void* buffer, const char* name) const noexcept {
+        if (std::string(name) == std::string("node" + std::to_string(id_) + "-offsets"))
+          offsets_.concatenate(reinterpret_cast<PRIMITIVE*>(buffer));
+        content_.to_buffer(buffer, name);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        offsets_.concatenate(reinterpret_cast<PRIMITIVE*>(
+            buffers["node" + std::to_string(id_) + "-offsets"]));
+        content_.to_char_buffers(buffers);
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        return "{ \"class\": \"ListOffsetArray\", \"offsets\": \"" +
+               type_to_numpy_like<PRIMITIVE>() +
+               "\", \"content\": " + content_.form() + params +
+               ", \"form_key\": \"" + form_key.str() + "\" }";
+      }
+
+    private:
+      /// @brief Buffer of `PRIMITIVE` type.
+      ///
+      /// It specifies the starting and stopping index of each list.
+      GrowableBuffer<PRIMITIVE> offsets_;
+
+      /// @brief The content of the ListOffsetArray.
+      BUILDER content_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+    };
+
+
+    /// @class Empty
+    ///
+    /// @brief Builds an EmptyArray which has no content in it.
+    /// It is used whenever an array's type is not known because it is empty.
+    class Empty {
+    public:
+      /// @brief Creates a new Empty layout builder.
+      Empty() {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      void
+      set_id(size_t& /* id */) noexcept {}
+
+      void
+      clear() noexcept {}
+
+      /// @brief Current length of the content.
+      size_t
+      length() const noexcept {
+        return 0;
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& /* error */) const noexcept {
+        return true;
+      }
+
+      void
+      buffer_nbytes(std::map<std::string, size_t>& /* names_nbytes */) const
+          noexcept {}
+
+      void
+      to_buffers(std::map<std::string, void*>& /* buffers */) const noexcept {}
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& /* buffers */) const noexcept {}
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        return "{ \"class\": \"EmptyArray\" }";
+      }
+
+    private:
+      /// @brief Unique form ID.
+      size_t id_;
+    };
+
+
+    /// @class Record
+    ///
+    /// @brief Builds a RecordArray which represents an array of records, which
+    /// can be of same or different types. Its contents is an ordered list of arrays
+    /// with the same length as the length of its shortest content; all are aligned
+    /// element-by-element, associating a field name to every content.
+    ///
+    /// @tparam MAP Map of index keys and field name.
+    /// @tparam BUILDERS The types of builder contents.
+    template <class MAP = std::map<std::size_t, std::string>,
+              typename... BUILDERS>
+    class Record {
+    public:
+      using RecordContents = typename std::tuple<BUILDERS...>;
+      using UserDefinedMap = MAP;
+
+      template <std::size_t INDEX>
+      using RecordFieldType = std::tuple_element_t<INDEX, RecordContents>;
+
+      /// @brief Creates a new Record layout builder.
+      Record() {
+        size_t id = 0;
+        set_id(id);
+        map_fields(std::index_sequence_for<BUILDERS...>());
+      }
+
+      /// @brief Creates a new Record layout builder, taking a user-defined
+      /// map with enumerated type field ID as keys and field names as value
+      /// which sets the field names.
+      ///
+      /// @param user_defined_field_id_to_name_map A user-defined field ID
+      /// field name map.
+      Record(UserDefinedMap user_defined_field_id_to_name_map)
+          : content_names_(user_defined_field_id_to_name_map) {
+        assert(content_names_.size() == fields_count_);
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns a vector of strings sontaining all the field names.
+      const std::vector<std::string>
+      fields() const noexcept {
+        if (content_names_.empty()) {
+          return fields_;
+        } else {
+          std::vector<std::string> result;
+          for (auto it : content_names_) {
+            result.emplace_back(it.second);
+          }
+          return result;
+        }
+      }
+
+      /// @brief Sets the field names.
+      ///
+      /// Alternative method to set the field names besides passing the
+      /// user-defined map as constructor parameter.
+      void
+      set_fields(MAP user_defined_field_id_to_name_map) noexcept {
+        content_names_ = user_defined_field_id_to_name_map;
+      }
+
+      /// @brief Returns the reference to the builder contents at `INDEX`.
+      template <std::size_t INDEX>
+      typename RecordFieldType<INDEX>::Builder&
+      content() noexcept {
+        return std::get<INDEX>(contents).builder;
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        for (size_t i = 0; i < fields_count_; i++) {
+          visit_at(contents, i, [&id](auto& content) {
+            content.builder.set_id(id);
+          });
+        }
+      }
+
+      /// @brief Clears the builder contents.
+      ///
+      /// Discards the accumulated data and the contents in each
+      /// field of the record.
+      void
+      clear() noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [](auto& content) {
+            content.builder.clear();
+          });
+      }
+
+      /// @brief Current number of records in first field.
+      size_t
+      length() const noexcept {
+        return (std::get<0>(contents).builder.length());
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        auto index_sequence((std::index_sequence_for<BUILDERS...>()));
+
+        int64_t length = -1;
+        std::vector<size_t> lengths = field_lengths(index_sequence);
+        for (size_t i = 0; i < lengths.size(); i++) {
+          if (length == -1) {
+            length = lengths[i];
+          }
+          else if (length != (int64_t)lengths[i]) {
+            std::stringstream out;
+            out << "Record node" << id_ << " has field \""
+                << fields().at(i) << "\" length " << lengths[i]
+                << " that differs from the first length " << length << "\n";
+            error.append(out.str());
+
+            return false;
+          }
+        }
+
+        std::vector<bool> valid_fields = field_is_valid(index_sequence, error);
+        return std::none_of(std::cbegin(valid_fields),
+                            std::cend(valid_fields),
+                            std::logical_not<bool>());
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&names_nbytes](auto& content) {
+            content.builder.buffer_nbytes(names_nbytes);
+          });
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&buffers](auto& content) {
+            content.builder.to_buffers(buffers);
+          });
+      }
+
+      void
+      to_buffer(void* buffer, const char* name) const noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&buffer, &name](auto& content) {
+            content.builder.to_buffer(buffer, name);
+          });
+      }
+      
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&buffers](auto& content) {
+            content.builder.to_char_buffers(buffers);
+          });
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string("\"parameters\": { " + parameters_ + " }, ");
+        }
+        std::stringstream out;
+        out << "{ \"class\": \"RecordArray\", \"contents\": { ";
+        for (size_t i = 0; i < fields_count_; i++) {
+          if (i != 0) {
+            out << ", ";
+          }
+          auto contents_form = [&](auto& content) {
+            out << "\""
+                << (!content_names_.empty() ? content_names_.at(content.index)
+                                            : content.index_as_field())
+                << +"\": ";
+            out << content.builder.form();
+          };
+          visit_at(contents, i, contents_form);
+        }
+        out << " }, ";
+        out << params << "\"form_key\": \"" << form_key.str() << "\" }";
+        return out.str();
+      }
+
+      /// @brief The contents of the RecordArray.
+      RecordContents contents;
+
+    private:
+      /// @brief Inserts the field names of all the record fields in a vector
+      /// of strings.
+      template <std::size_t... S>
+      void
+      map_fields(std::index_sequence<S...>) noexcept {
+        fields_ = std::vector<std::string>(
+            {std::string(std::get<S>(contents).index_as_field())...});
+      }
+
+      /// @brief Inserts the lengths of all the record fields in a vector and
+      /// returns the vector.
+      template <std::size_t... S>
+      std::vector<size_t>
+      field_lengths(std::index_sequence<S...>) const noexcept {
+        return std::vector<size_t>({std::get<S>(contents).builder.length()...});
+      }
+
+      /// @brief Helper function of #is_valid for checking the validity.
+      template <std::size_t... S>
+      std::vector<bool>
+      field_is_valid(std::index_sequence<S...>, std::string& error) const
+          noexcept {
+        return std::vector<bool>(
+            {std::get<S>(contents).builder.is_valid(error)...});
+      }
+
+      /// @brief Vector of strings of field names.
+      std::vector<std::string> fields_;
+
+      /// @brief User-defined map of record field names.
+      UserDefinedMap content_names_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief The count of the fields in the builder.
+      static constexpr size_t fields_count_ = sizeof...(BUILDERS);
+    };
+
+    /// @class Tuple
+    ///
+    /// @brief Builds a RecordArray which represents an array of tuples which can be
+    /// of same or different types without field names, indexed only by their order.
+    ///
+    /// @tparam BUILDERS The types of builder contents.
+    template <typename... BUILDERS>
+    class Tuple {
+      using TupleContents = typename std::tuple<BUILDERS...>;
+
+      template <std::size_t INDEX>
+      using TupleContentType = std::tuple_element_t<INDEX, TupleContents>;
+
+    public:
+      /// @brief Creates a new Tuple layout builder.
+      Tuple() {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns the reference to the builder contents at `INDEX`.
+      template <std::size_t INDEX>
+      TupleContentType<INDEX>&
+      content() noexcept {
+        return std::get<INDEX>(contents);
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        for (size_t i = 0; i < fields_count_; i++) {
+          visit_at(contents, i, [&id](auto& content) {
+            content.set_id(id);
+          });
+        }
+      }
+
+      /// @brief Clears the builder contents.
+      ///
+      /// Discards the accumulated data and the contents at each tuple index.
+      void
+      clear() noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [](auto& content) {
+            content.clear();
+          });
+      }
+
+      /// @brief Current number of records in the first index of the tuple.
+      size_t
+      length() const noexcept {
+        return (std::get<0>(contents).length());
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        auto index_sequence((std::index_sequence_for<BUILDERS...>()));
+
+        int64_t length = -1;
+        std::vector<size_t> lengths = content_lengths(index_sequence);
+        for (size_t i = 0; i < lengths.size(); i++) {
+          if (length == -1) {
+            length = (int64_t)lengths[i];
+          }
+          else if (length != (int64_t)lengths[i]) {
+            std::stringstream out;
+            out << "Record node" << id_ << " has index \"" << i << "\" length "
+                << lengths[i] << " that differs from the first length "
+                << length << "\n";
+            error.append(out.str());
+
+            return false;
+          }
+        }
+
+        std::vector<bool> valid_fields =
+            content_is_valid(index_sequence, error);
+        return std::none_of(std::cbegin(valid_fields),
+                            std::cend(valid_fields),
+                            std::logical_not<bool>());
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&names_nbytes](auto& content) {
+            content.buffer_nbytes(names_nbytes);
+          });
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&buffers](auto& content) {
+            content.to_buffers(buffers);
+          });
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        for (size_t i = 0; i < fields_count_; i++)
+          visit_at(contents, i, [&buffers](auto& content) {
+            content.to_char_buffers(buffers);
+          });
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string("\"parameters\": { " + parameters_ + " }, ");
+        }
+        std::stringstream out;
+        out << "{ \"class\": \"RecordArray\", \"contents\": [";
+        for (size_t i = 0; i < fields_count_; i++) {
+          if (i != 0) {
+            out << ", ";
+          }
+          auto contents_form = [&out](auto& content) {
+            out << content.form();
+          };
+          visit_at(contents, i, contents_form);
+        }
+        out << "], ";
+        out << params << "\"form_key\": \"" << form_key.str() << "\" }";
+        return out.str();
+      }
+
+      /// @brief The contents of the RecordArray without fields.
+      TupleContents contents;
+
+    private:
+      /// @brief Inserts the lengths of all the builder contents in a vector
+      /// and returns the vector.
+      template <std::size_t... S>
+      std::vector<size_t>
+      content_lengths(std::index_sequence<S...>) const noexcept {
+        return std::vector<size_t>({std::get<S>(contents).length()...});
+      }
+
+      /// @brief Helper function of #is_valid for checking the validity.
+      template <std::size_t... S>
+      std::vector<bool>
+      content_is_valid(std::index_sequence<S...>, std::string& error) const
+          noexcept {
+        return std::vector<bool>({std::get<S>(contents).is_valid(error)...});
+      }
+
+      /// @brief Vector of integers of field index.
+      std::vector<int64_t> field_index_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief The count of the fields in the builder.
+      static constexpr size_t fields_count_ = sizeof...(BUILDERS);
+    };
+
+    /// @class Regular
+    ///
+    /// @brief Builds a RegularArray that describes lists that have the same
+    /// length, a single integer size. Its underlying content is a flattened
+    /// view of the data; that is, each list is not stored separately in memory,
+    /// but is inferred as a subinterval of the underlying data.
+    ///
+    /// A multidimensional {@link Numpy NumpyArray} is equivalent to a one-dimensional
+    /// {@link Numpy NumpyArray} nested within several RegularArrays, one for each
+    /// dimension. However, RegularArrays can be used to make lists of any other type.
+    ///
+    /// @tparam SIZE
+    /// @tparam BUILDER The type of builder content.
+    template <unsigned SIZE, typename BUILDER>
+    class Regular {
+    public:
+      /// @brief Creates a new Regular layout builder.
+      Regular() : length_(0) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns the reference to the builder content.
+      BUILDER&
+      content() noexcept {
+        return content_;
+      }
+
+      /// @brief Begins a list and returns the reference to the content
+      /// of the builder.
+      BUILDER&
+      begin_list() noexcept {
+        return content_;
+      }
+
+      /// @brief Ends a list and increments the number of lists.
+      void
+      end_list() noexcept {
+        length_++;
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        content_.set_id(id);
+      }
+
+      /// @brief Clears the builder content.
+      void
+      clear() noexcept {
+        length_ = 0;
+        content_.clear();
+      }
+
+      /// @brief Current number of lists of length `SIZE`.
+      size_t
+      length() const noexcept {
+        return length_;
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        if (content_.length() != length_ * size_) {
+          std::stringstream out;
+          out << "Regular node" << id_ << "has content length "
+              << content_.length() << ", but length " << length_ << " and size "
+              << size_ << "\n";
+          error.append(out.str());
+
+          return false;
+        } else {
+          return content_.is_valid(error);
+        }
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        content_.buffer_nbytes(names_nbytes);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        content_.to_buffers(buffers);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        content_.to_char_buffers(buffers);
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        return "{ \"class\": \"RegularArray\", \"content\": " +
+               content_.form() + ", \"size\": " + std::to_string(size_) +
+               params + ", \"form_key\": \"" + form_key.str() + "\" }";
+      }
+
+    private:
+      /// @brief The content of the RegularArray.
+      BUILDER content_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief Current number of lists of length `SIZE`.
+      size_t length_;
+
+      /// @brief Length of each list.
+      size_t size_ = SIZE;
+    };
+
+
+    /// @class IndexedOption
+    ///
+    /// @brief Builds an IndexedOptionArray which consists of an `index` buffer.
+    /// The negative values in the index are interpreted as missing.
+    ///
+    /// The index values can be 64-bit signed integers `int64`, 32-bit signed
+    /// integers `int32`.
+    ///
+    /// @tparam PRIMITIVE The type of `index` buffer.
+    /// @tparam BUILDER The type of builder content.
+    template <typename PRIMITIVE, typename BUILDER>
+    class IndexedOption {
+    public:
+      /// @brief Creates a new IndexedOption layout builder by allocating a new `index`
+      /// buffer, using `AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS` for initializing the buffer.
+      IndexedOption()
+          : index_(
+                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)),
+            last_valid_(-1) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Creates a new IndexedOption layout builder by allocating a new `index`
+      /// buffer, taking `options` from {@link BuilderOptions BuilderOptions}
+      /// for initializing the buffer.
+      ///
+      /// @param options Initial size configuration of a buffer.
+      IndexedOption(const awkward::BuilderOptions& options)
+          : index_(awkward::GrowableBuffer<PRIMITIVE>(options)),
+            last_valid_(-1) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns the reference to the builder content.
+      BUILDER&
+      content() noexcept {
+        return content_;
+      }
+
+      /// @brief Inserts the last valid index in the `index` buffer and
+      /// returns the reference to the builder content.
+      BUILDER&
+      append_valid() noexcept {
+        last_valid_ = content_.length();
+        index_.append(last_valid_);
+        return content_;
+      }
+
+      /// @brief Inserts `size` number of valid index in the `index` buffer
+      /// and returns the reference to the builder content.
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      BUILDER&
+      extend_valid(size_t size) noexcept {
+        size_t start = content_.length();
+        size_t stop = start + size;
+        last_valid_ = stop - 1;
+        for (size_t i = start; i < stop; i++) {
+          index_.append(i);
+        }
+        return content_;
+      }
+
+      /// @brief Inserts `-1` in the `index` buffer.
+      void
+      append_invalid() noexcept {
+        index_.append(-1);
+      }
+
+      /// @brief Inserts `-1` in the `index` buffer `size` number of times
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      void
+      extend_invalid(size_t size) noexcept {
+        for (size_t i = 0; i < size; i++) {
+          index_.append(-1);
+        }
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        content_.set_id(id);
+      }
+
+      /// @brief Discards the accumulated index and clears the content
+      /// of the builder. Also, last valid returns to `-1`.
+      void
+      clear() noexcept {
+        last_valid_ = -1;
+        index_.clear();
+        content_.clear();
+      }
+
+      /// @brief Current length of the `index` buffer.
+      size_t
+      length() const noexcept {
+        return index_.length();
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        if (content_.length() != last_valid_ + 1) {
+          std::stringstream out;
+          out << "IndexedOption node" << id_ << " has content length "
+              << content_.length() << " but last valid index is " << last_valid_
+              << "\n";
+          error.append(out.str());
+
+          return false;
+        } else {
+          return content_.is_valid(error);
+        }
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        names_nbytes["node" + std::to_string(id_) + "-index"] = index_.nbytes();
+        content_.buffer_nbytes(names_nbytes);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        index_.concatenate(reinterpret_cast<PRIMITIVE*>(
+            buffers["node" + std::to_string(id_) + "-index"]));
+        content_.to_buffers(buffers);
+      }
+
+      void
+      to_buffer(void* buffer, const char* name) const noexcept {
+        if (std::string(name) == std::string("node" + std::to_string(id_) + "-index"))
+          index_.concatenate(reinterpret_cast<PRIMITIVE*>(buffer));
+        content_.to_buffer(buffer, name);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        index_.concatenate(reinterpret_cast<PRIMITIVE*>(
+            buffers["node" + std::to_string(id_) + "-index"]));
+        content_.to_char_buffers(buffers);
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        return "{ \"class\": \"IndexedOptionArray\", \"index\": \"" +
+               type_to_numpy_like<PRIMITIVE>() +
+               "\", \"content\": " + content_.form() + params +
+               ", \"form_key\": \"" + form_key.str() + "\" }";
+      }
+
+    private:
+      /// @brief Buffer of `PRIMITIVE` type.
+      ///
+      /// It specifies the index of each element.
+      GrowableBuffer<PRIMITIVE> index_;
+
+      /// @brief The content of the IndexedOptionArray.
+      BUILDER content_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief Last valid index.
+      size_t last_valid_;
+    };
+
+    /// @class Unmasked
+    ///
+    /// @brief Builds an UnmaskedArray which the values are never, in fact, missing.
+    /// It exists to satisfy systems that formally require this high-level type without
+    /// the overhead of generating an array of all True or all False values.
+    ///
+    /// This is similar to NumPy's
+    /// [masked arrays](https://numpy.org/doc/stable/reference/maskedarray.html)
+    /// with mask=None.
+    ///
+    /// @tparam BUILDER The type of builder content.
+    template <typename BUILDER>
+    class Unmasked {
+    public:
+      /// @brief Creates a new Unmasked layout builder.
+      Unmasked() {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns the reference to the builder content.
+      BUILDER&
+      content() noexcept {
+        return content_;
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        content_.set_id(id);
+      }
+
+      /// @brief Clears the builder content.
+      void
+      clear() noexcept {
+        content_.clear();
+      }
+
+      /// @brief Current length of the content.
+      size_t
+      length() const noexcept {
+        return content_.length();
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        return content_.is_valid(error);
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        content_.buffer_nbytes(names_nbytes);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        content_.to_buffers(buffers);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        content_.to_char_buffers(buffers);
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        return "{ \"class\": \"UnmaskedArray\", \"content\": " +
+               content_.form() + params + ", \"form_key\": \"" +
+               form_key.str() + "\" }";
+      }
+
+    private:
+      /// @brief The content of the UnmaskedArray.
+      BUILDER content_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+    };
+
+    /// @class ByteMasked
+    ///
+    /// @brief Builds a ByteMaskedArray using a mask which is an array
+    /// of booleans that determines whether the corresponding value in the
+    /// contents array is valid or not.
+    ///
+    /// If an element of the mask is equal to #valid_when, the corresponding
+    /// element of the builder content is valid and unmasked, else it is
+    /// invalid (missing) and masked.
+    ///
+    /// This is similar to NumPy's
+    /// [masked arrays](https://numpy.org/doc/stable/reference/maskedarray.html)
+    /// if #valid_when = `false`.
+    ///
+    /// @tparam VALID_WHEN A boolean value which determines when the builder content are valid.
+    /// @tparam BUILDER The type of builder content.
+    template <bool VALID_WHEN, typename BUILDER>
+    class ByteMasked {
+    public:
+      /// @brief Creates a new ByteMasked layout builder by allocating a new `mask`
+      ///  buffer, using `AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS` for initializing the buffer.
+      ByteMasked()
+          : mask_(awkward::GrowableBuffer<int8_t>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Creates a new ByteMasked layout builder by allocating a new `mask`
+      /// buffer, taking `options` from {@link BuilderOptions BuilderOptions}
+      /// for initializing the buffer.
+      ///
+      /// @param options Initial size configuration of a buffer.
+      ByteMasked(const awkward::BuilderOptions& options)
+          : mask_(awkward::GrowableBuffer<int8_t>(options)) {
+        size_t id = 0;
+        set_id(id);
+      }
+
+      /// @brief Returns the reference to the builder content.
+      BUILDER&
+      content() noexcept {
+        return content_;
+      }
+
+      /// @brief Determines when the builder content are valid.
+      bool
+      valid_when() const noexcept {
+        return valid_when_;
+      }
+
+      /// @brief Inserts #valid_when in the mask.
+      ///
+      /// After this, a valid element is inserted in the builder content.
+      BUILDER&
+      append_valid() noexcept {
+        mask_.append(valid_when_);
+        return content_;
+      }
+
+      /// @brief Inserts `size` number of #valid_when in the mask.
+      ///
+      /// After this, `size` number of valid elements are inserted in the builder content.
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      BUILDER&
+      extend_valid(size_t size) noexcept {
+        for (size_t i = 0; i < size; i++) {
+          mask_.append(valid_when_);
+        }
+        return content_;
+      }
+
+      /// @brief Inserts !valid_when in the mask.
+      ///
+      /// After this, a dummy (invalid) value is inserted in the builder content.
+      BUILDER&
+      append_invalid() noexcept {
+        mask_.append(!valid_when_);
+        return content_;
+      }
+
+      /// @brief Inserts `size` number of !valid_when in the mask.
+      ///
+      /// After this, `size` number of dummy (invalid) values are inserted in the builder content.
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      BUILDER&
+      extend_invalid(size_t size) noexcept {
+        for (size_t i = 0; i < size; i++) {
+          mask_.append(!valid_when_);
+        }
+        return content_;
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        content_.set_id(id);
+      }
+
+      /// @brief Discards the accumulated mask and clears the content
+      /// of the builder.
+      void
+      clear() noexcept {
+        mask_.clear();
+        content_.clear();
+      }
+
+      /// @brief Current length of the `mask` buffer.
+      size_t
+      length() const noexcept {
+        return mask_.length();
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        if (content_.length() != mask_.length()) {
+          std::stringstream out;
+          out << "ByteMasked node" << id_ << "has content length "
+              << content_.length() << "but mask length " << mask_.length()
+              << "\n";
+          error.append(out.str());
+
+          return false;
+        } else {
+          return content_.is_valid(error);
+        }
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        names_nbytes["node" + std::to_string(id_) + "-mask"] = mask_.nbytes();
+        content_.buffer_nbytes(names_nbytes);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        mask_.concatenate(reinterpret_cast<int8_t*>(
+            buffers["node" + std::to_string(id_) + "-mask"]));
+        content_.to_buffers(buffers);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        mask_.concatenate(reinterpret_cast<int8_t*>(
+            buffers["node" + std::to_string(id_) + "-mask"]));
+        content_.to_char_buffers(buffers);
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key, form_valid_when;
+        form_key << "node" << id_;
+        form_valid_when << std::boolalpha << valid_when_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        return "{ \"class\": \"ByteMaskedArray\", \"mask\": \"i8\", "
+               "\"content\": " +
+               content_.form() + ", \"valid_when\": " + form_valid_when.str() +
+               params + ", \"form_key\": \"" + form_key.str() + "\" }";
+      }
+
+    private:
+      /// @brief Buffer of `int8` type.
+      ///
+      /// It specifies the mask value of each element.
+      GrowableBuffer<int8_t> mask_;
+
+      /// @brief The content of the ByteMaskedArray.
+      BUILDER content_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief Determines when the builder content are valid.
+      bool valid_when_ = VALID_WHEN;
+    };
+
+    /// @class BitMasked
+    ///
+    /// @brief Builds a BitMaskedArray in which mask values are packed into a bitmap.
+    ///
+    /// It has an additional parameter, #lsb_order; If `true`, the position of each bit is in
+    /// `Least-Significant Bit order (LSB)` and if it is `false`, then in `Most-Significant Bit
+    /// order (MSB)`.
+    ///
+    /// This is similar to NumPy's
+    /// [unpackbits](https://numpy.org/doc/stable/reference/generated/numpy.unpackbits.html)
+    /// with `bitorder="little"` for LSB, `bitorder="big"` for MSB.
+    ///
+    /// @tparam VALID_WHEN A boolean value which determines when the builder content are valid.
+    /// @tparam LSB_ORDER A boolean value which determines whether the position of each bit is
+    /// in LSB order or not.
+    /// @tparam BUILDER The type of builder content.
+    template <bool VALID_WHEN, bool LSB_ORDER, typename BUILDER>
+    class BitMasked {
+    public:
+      /// @brief Creates a new BitMasked layout builder by allocating a new `mask`
+      /// buffer, using `AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS` for initializing the buffer.
+      BitMasked()
+          : mask_(awkward::GrowableBuffer<uint8_t>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)),
+            current_byte_(uint8_t(0)),
+            current_byte_ref_(mask_.append_and_get_ref(current_byte_)),
+            current_index_(0) {
+        size_t id = 0;
+        set_id(id);
+        if (lsb_order_) {
+          for (size_t i = 0; i < 8; i++) {
+            cast_[i] = 1 << i;
+          }
+        } else {
+          for (size_t i = 0; i < 8; i++) {
+            cast_[i] = 128 >> i;
+          }
+        }
+      }
+
+      /// @brief Creates a new BitMasked layout builder by allocating a new `mask`
+      /// buffer, taking `options` from {@link BuilderOptions BuilderOptions}
+      /// for initializing the buffer.
+      ///
+      /// @param options Initial size configuration of a buffer.
+      BitMasked(const awkward::BuilderOptions& options)
+          : mask_(awkward::GrowableBuffer<uint8_t>(options)),
+            current_byte_(uint8_t(0)),
+            current_byte_ref_(mask_.append_and_get_ref(current_byte_)),
+            current_index_(0) {
+        size_t id = 0;
+        set_id(id);
+        if (lsb_order_) {
+          for (size_t i = 0; i < 8; i++) {
+            cast_[i] = 1 << i;
+          }
+        } else {
+          for (size_t i = 0; i < 8; i++) {
+            cast_[i] = 128 >> i;
+          }
+        }
+      }
+
+      /// @brief Returns the reference to the builder content.
+      BUILDER&
+      content() noexcept {
+        return content_;
+      }
+
+      /// @brief Determines when the builder content are valid.
+      bool
+      valid_when() const noexcept {
+        return valid_when_;
+      }
+
+      /// @brief Determines whether the position of each bit is in
+      /// Least-Significant Bit order (LSB) or not.
+      bool
+      lsb_order() const noexcept {
+        return lsb_order_;
+      }
+
+      /// @brief Sets a bit in the mask.
+      /// If current_byte_ and cast_: `0` indicates `null`, `1` indicates `valid` and vice versa.
+      ///
+      /// After this, a valid element is inserted in the builder content.
+      BUILDER&
+      append_valid() noexcept {
+        append_begin();
+        current_byte_ |= cast_[current_index_];
+        append_end();
+        return content_;
+      }
+
+      /// @brief Sets `size` number of bits in the mask.
+      /// If current_byte_ and cast_: `0` indicates `null`, `1` indicates `valid` and vice versa.
+      ///
+      /// After this, `size` number of valid elements are inserted in the builder content.
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      BUILDER&
+      extend_valid(size_t size) noexcept {
+        for (size_t i = 0; i < size; i++) {
+          append_valid();
+        }
+        return content_;
+      }
+
+      /// @brief Sets current_byte_ and cast_ default to null, no change in current_byte_.
+      ///
+      /// After this, a dummy (invalid) value is inserted in the builder content.
+      BUILDER&
+      append_invalid() noexcept {
+        append_begin();
+        append_end();
+        return content_;
+      }
+
+      /// @brief Sets current_byte_ and cast_ default to null, no change in current_byte_.
+      ///
+      /// After this, `size` number of dummy (invalid) values are inserted in the builder content.
+      ///
+      /// Just an interface; not actually faster than calling append many times.
+      BUILDER&
+      extend_invalid(size_t size) noexcept {
+        for (size_t i = 0; i < size; i++) {
+          append_invalid();
+        }
+        return content_;
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        content_.set_id(id);
+      }
+
+      /// @brief Discards the accumulated mask and clears the content
+      /// of the builder.
+      void
+      clear() noexcept {
+        mask_.clear();
+        content_.clear();
+        current_byte_ = 0;
+        current_byte_ref_ = mask_.append_and_get_ref(current_byte_);
+        current_index_ = 0;
+      }
+
+      /// @brief Current length of the `mask` buffer.
+      size_t
+      length() const noexcept {
+        return mask_.length() > 0 ?
+          (mask_.length() - 1) * 8 + current_index_ : current_index_;
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        if (content_.length() != length()) {
+          std::stringstream out;
+          out << "BitMasked node" << id_ << "has content length "
+              << content_.length() << "but bit mask length " << mask_.length()
+              << "\n";
+          error.append(out.str());
+
+          return false;
+        } else {
+          return content_.is_valid(error);
+        }
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        names_nbytes["node" + std::to_string(id_) + "-mask"] = mask_.nbytes();
+        content_.buffer_nbytes(names_nbytes);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        mask_.concatenate_from(reinterpret_cast<uint8_t*>(
+            buffers["node" + std::to_string(id_) + "-mask"]), 0, 1);
+        mask_.append(reinterpret_cast<uint8_t*>(
+            buffers["node" + std::to_string(id_) + "-mask"]), mask_.length() - 1, 0, 1);
+        content_.to_buffers(buffers);
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        mask_.concatenate_from(reinterpret_cast<uint8_t*>(
+            buffers["node" + std::to_string(id_) + "-mask"]), 0, 1);
+        mask_.append(reinterpret_cast<uint8_t*>(
+            buffers["node" + std::to_string(id_) + "-mask"]), mask_.length() - 1, 0, 1);
+        content_.to_char_buffers(buffers);
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key, form_valid_when, form_lsb_order;
+        form_key << "node" << id_;
+        form_valid_when << std::boolalpha << valid_when_;
+        form_lsb_order << std::boolalpha << lsb_order_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        return "{ \"class\": \"BitMaskedArray\", \"mask\": \"u8\", "
+               "\"content\": " +
+               content_.form() + ", \"valid_when\": " + form_valid_when.str() +
+               ", \"lsb_order\": " + form_lsb_order.str() + params +
+               ", \"form_key\": \"" + form_key.str() + "\" }";
+      }
+
+    private:
+      /// @brief Inserts a byte in the mask buffer when `current_index_` equals `8`,
+      /// returns it reference to the `current_byte_ref_` and resets `current_byte_`
+      /// and `current_index_`.
+      void
+      append_begin() {
+        if (current_index_ == 8) {
+          current_byte_ref_ = mask_.append_and_get_ref(current_byte_);
+          current_byte_ = uint8_t(0);
+          current_index_ = 0;
+        }
+      }
+
+      /// @brief Updates the `current_index_` and `current_byte_ref_` according to
+      /// the value of #valid_when.
+      ///
+      /// If #valid_when equals `true`: `0` indicates `null`, `1` indicates `valid`.
+      /// If #valid_when equals `false`: `0` indicates `valid`, `1` indicates `null`.
+      void
+      append_end() {
+        current_index_ += 1;
+        if (valid_when_) {
+          current_byte_ref_ = current_byte_;
+        } else {
+          current_byte_ref_ = ~current_byte_;
+        }
+      }
+
+      /// @brief Buffer of `uint8` type.
+      ///
+      /// It specifies the mask value of each element.
+      GrowableBuffer<uint8_t> mask_;
+
+      /// @brief The content of the BitMaskedArray.
+      BUILDER content_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief The current byte.
+      uint8_t current_byte_;
+
+      /// @brief Stores the reference to the current byte.
+      uint8_t& current_byte_ref_;
+
+      /// @brief The current index.
+      size_t current_index_;
+
+      /// @brief Array of bytes used to set the bit.
+      uint8_t cast_[8];
+
+      /// @brief Determines when the builder content are valid.
+      bool valid_when_ = VALID_WHEN;
+
+      /// @brief Determines whether the position of each bit is in
+      /// Least-Significant Bit order (LSB) or not.
+      bool lsb_order_ = LSB_ORDER;
+    };
+
+    /// @class Union
+    ///
+    /// @brief Builds a UnionArray which represents data drawn from an ordered
+    /// list of contents, which can have different types, using tags, which is an
+    /// array of integers indicating which content each array element draws from and
+    /// index, which is an array of integers indicating which element from the content
+    /// to draw from.
+    ///
+    /// The index values can be 64-bit signed integers `int64`, 32-bit signed integers
+    /// `int32` or 32-bit unsigned integers `uint32` and the tags values can be 8-bit
+    /// signed integers.
+    ///
+    /// @tparam TAGS The type of `tags` buffer.
+    /// @tparam INDEX The type of `index` buffer.
+    /// @tparam BUILDERS The types of builder contents.
+    template <typename TAGS, typename INDEX, typename... BUILDERS>
+    class Union {
+    public:
+      using Contents = typename std::tuple<BUILDERS...>;
+
+      template <std::size_t I>
+      using ContentType = std::tuple_element_t<I, Contents>;
+
+      /// @brief Creates a new Union layout builder by allocating new tags and
+      /// index buffers, using `AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS` for initializing the buffer.
+      Union()
+          : tags_(awkward::GrowableBuffer<TAGS>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)),
+            index_(awkward::GrowableBuffer<INDEX>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
+        size_t id = 0;
+        set_id(id);
+        for (size_t i = 0; i < contents_count_; i++)
+          last_valid_index_[i] = -1;
+      }
+
+      /// @brief Creates a new Union layout builder by allocating new tags and index
+      /// buffers, taking `options` from {@link BuilderOptions BuilderOptions}
+      /// for initializing the buffer.
+      ///
+      /// @param options Initial size configuration of a buffer.
+      Union(const awkward::BuilderOptions& options)
+          : tags_(awkward::GrowableBuffer<TAGS>(options)),
+            index_(awkward::GrowableBuffer<INDEX>(options)) {
+        size_t id = 0;
+        set_id(id);
+        for (size_t i = 0; i < contents_count_; i++)
+          last_valid_index_[i] = -1;
+      }
+
+      template <std::size_t I>
+      ContentType<I>&
+      content() noexcept {
+        return std::get<I>(contents_);
+      }
+
+      /// @brief Inserts the current tag in the `tags` buffer and the next index in the
+      /// `index` buffer and returns the reference to the content of the current builder.
+      template <std::size_t TAG>
+      ContentType<TAG>&
+      append_content() noexcept {
+        auto& which_content = std::get<TAG>(contents_);
+        INDEX next_index = which_content.length();
+
+        TAGS tag = (TAGS)TAG;
+        last_valid_index_[tag] = next_index;
+        tags_.append(tag);
+        index_.append(next_index);
+
+        return which_content;
+      }
+
+      /// @brief Parameters for the builder form.
+      const std::string&
+      parameters() const noexcept {
+        return parameters_;
+      }
+
+      /// @brief Sets the form parameters.
+      void
+      set_parameters(std::string parameter) noexcept {
+        parameters_ = parameter;
+      }
+
+      /// @brief Assigns a unique ID to each node.
+      void
+      set_id(size_t& id) noexcept {
+        id_ = id;
+        id++;
+        auto contents_id = [&id](auto& content) {
+          content.set_id(id);
+        };
+        for (size_t i = 0; i < contents_count_; i++)
+          visit_at(contents_, i, contents_id);
+      }
+
+      /// @brief Discards the accumulated tags and index, and clears
+      /// the builder contents.
+      ///
+      /// Also, resets the last valid index array to `-1`.
+      void
+      clear() noexcept {
+        for (size_t i = 0; i < contents_count_; i++)
+          last_valid_index_[i] = -1;
+        tags_.clear();
+        index_.clear();
+        auto clear_contents = [](auto& content) {
+          content.clear();
+        };
+        for (size_t i = 0; i < contents_count_; i++)
+          visit_at(contents_, i, clear_contents);
+      }
+
+      /// @brief Current length of the `tags` buffer.
+      size_t
+      length() const noexcept {
+        return tags_.length();
+      }
+
+      /// @brief Checks for validity and consistency.
+      bool
+      is_valid(std::string& error) const noexcept {
+        auto index_sequence((std::index_sequence_for<BUILDERS...>()));
+
+        std::vector<size_t> lengths = content_lengths(index_sequence);
+        for (size_t tag = 0; tag < contents_count_; tag++) {
+          if (lengths[tag] != last_valid_index_[tag] + 1) {
+            std::stringstream out;
+            out << "Union node" << id_ << " has content length " << lengths[tag]
+                << " but index length " << last_valid_index_[tag] << "\n";
+            error.append(out.str());
+
+            return false;
+          }
+        }
+
+        std::vector<bool> valid_contents =
+            content_is_valid(index_sequence, error);
+        return std::none_of(std::cbegin(valid_contents),
+                            std::cend(valid_contents),
+                            std::logical_not<bool>());
+      }
+
+      /// @brief Retrieves the names and sizes (in bytes) of the buffers used
+      /// in the builder and its contents.
+      void
+      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
+          noexcept {
+        auto index_sequence((std::index_sequence_for<BUILDERS...>()));
+
+        names_nbytes["node" + std::to_string(id_) + "-tags"] = tags_.nbytes();
+        names_nbytes["node" + std::to_string(id_) + "-index"] = index_.nbytes();
+
+        for (size_t i = 0; i < contents_count_; i++)
+          visit_at(contents_, i, [&names_nbytes](auto& content) {
+            content.buffer_nbytes(names_nbytes);
+          });
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in each of the
+      /// buffers of the builder and its contents to user-defined pointers.
+      ///
+      /// Used to fill the buffers map by allocating it with user-defined pointers
+      /// using the same names and sizes (in bytes) obtained from #buffer_nbytes.
+      void
+      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
+        auto index_sequence((std::index_sequence_for<BUILDERS...>()));
+
+        tags_.concatenate(reinterpret_cast<TAGS*>(
+            buffers["node" + std::to_string(id_) + "-tags"]));
+        index_.concatenate(reinterpret_cast<INDEX*>(
+            buffers["node" + std::to_string(id_) + "-index"]));
+
+        for (size_t i = 0; i < contents_count_; i++)
+          visit_at(contents_, i, [&buffers](auto& content) {
+            content.to_buffers(buffers);
+          });
+      }
+
+      /// @brief Copies and concatenates all the accumulated data in the builder
+      /// to a map of user-allocated buffers.
+      ///
+      /// The map keys and the buffer sizes are obtained from #buffer_nbytes
+      void
+      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
+        auto index_sequence((std::index_sequence_for<BUILDERS...>()));
+
+        tags_.concatenate(reinterpret_cast<TAGS*>(
+            buffers["node" + std::to_string(id_) + "-tags"]));
+        index_.concatenate(reinterpret_cast<INDEX*>(
+            buffers["node" + std::to_string(id_) + "-index"]));
+
+        for (size_t i = 0; i < contents_count_; i++)
+          visit_at(contents_, i, [&buffers](auto& content) {
+            content.to_char_buffers(buffers);
+          });
+      }
+
+      /// @brief Generates a unique description of the builder and its
+      /// contents in the form of a JSON-like string.
+      std::string
+      form() const noexcept {
+        std::stringstream form_key;
+        form_key << "node" << id_;
+        std::string params("");
+        if (parameters_ == "") {
+        } else {
+          params = std::string(", \"parameters\": { " + parameters_ + " }");
+        }
+        std::stringstream out;
+        out << "{ \"class\": \"UnionArray\", \"tags\": \"" +
+                   type_to_numpy_like<TAGS>() + "\", \"index\": \"" +
+                   type_to_numpy_like<INDEX>() + "\", \"contents\": [";
+        for (size_t i = 0; i < contents_count_; i++) {
+          if (i != 0) {
+            out << ", ";
+          }
+          auto contents_form = [&](auto& content) {
+            out << content.form();
+          };
+          visit_at(contents_, i, contents_form);
+        }
+        out << "], ";
+        out << params << "\"form_key\": \"" << form_key.str() << "\" }";
+        return out.str();
+      }
+
+    private:
+      /// @brief Inserts the lengths of all the builder contents in a vector
+      /// and returns the vector.
+      template <std::size_t... S>
+      std::vector<size_t>
+      content_lengths(std::index_sequence<S...>) const {
+        return std::vector<size_t>({std::get<S>(contents_).length()...});
+      }
+
+      /// @brief Helper function of #is_valid for checking the validity.
+      template <std::size_t... S>
+      std::vector<bool>
+      content_is_valid(std::index_sequence<S...>, std::string& error) const {
+        return std::vector<bool>({std::get<S>(contents_).is_valid(error)...});
+      }
+
+      /// @brief Buffer of `TAGS` type.
+      ///
+      /// It specifies the index of each Tuple content.
+      GrowableBuffer<TAGS> tags_;
+
+      /// @brief Buffer of `INDEX` type.
+      ///
+      /// It specifies the index of each element.
+      GrowableBuffer<INDEX> index_;
+
+      /// @brief The contents of the UnionArray.
+      Contents contents_;
+
+      /// @brief Form parameters.
+      std::string parameters_;
+
+      /// @brief Unique form ID.
+      size_t id_;
+
+      /// @brief Last valid index array.
+      size_t last_valid_index_[sizeof...(BUILDERS)];
+
+      /// @brief The count of the Tuple contents in the builder.
+      static constexpr size_t contents_count_ = sizeof...(BUILDERS);
+    };
+
+  }  // namespace LayoutBuilder
+}  // namespace awkward
+
+#endif  // AWKWARD_LAYOUTBUILDER_H_
diff --git a/src-fake-test/fake.cpp b/src-fake-test/fake.cpp
new file mode 100644
index 0000000..34e46fb
--- /dev/null
+++ b/src-fake-test/fake.cpp
@@ -0,0 +1,149 @@
+#include "fake.h"
+#include "LayoutBuilder.h"
+
+UserDefinedMap fake_fields_map({
+	{Field_fake::points, "points"}});
+
+UserDefinedMap points_fields_map({
+	{Field_points::x, "x"},
+	{Field_points::y, "y"},
+	{Field_points::z, "z"}});
+
+fake_t::fake_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, fake_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = this;
+    m_points = 0;
+
+    fake_builder.set_fields(fake_fields_map);
+
+    try {
+        _read();
+    } catch(...) {
+        _clean_up();
+        throw;
+    }
+}
+
+void fake_t::_read() {
+    m_points = new std::vector<point_t*>();
+    {
+        int i = 0;
+        auto& sub_points_builder = fake_builder.content<Field_fake::points>();
+
+        while (!m__io->is_eof()) {
+            sub_points_builder.begin_list();
+            m_points->push_back(new point_t(m__io, this, m__root));
+            sub_points_builder.end_list();
+            i++;
+        }
+    }
+}
+
+fake_t::~fake_t() {
+    _clean_up();
+}
+
+void fake_t::_clean_up() {
+    if (m_points) {
+        for (std::vector<point_t*>::iterator it = m_points->begin(); it != m_points->end(); ++it) {
+            delete *it;
+        }
+        delete m_points; m_points = 0;
+    }
+}
+
+fake_t::point_t::point_t(kaitai::kstream* p__io, fake_t* p__parent, fake_t* p__root) : kaitai::kstruct(p__io),
+	points_builder(p__parent->fake_builder.content<Field_fake::points>().content()) {
+    m__parent = p__parent;
+    m__root = p__root;
+
+    points_builder.set_fields(points_fields_map);
+
+    try {
+        _read();
+    } catch(...) {
+        _clean_up();
+        throw;
+    }
+}
+
+void fake_t::point_t::_read() {
+    m_x = m__io->read_u4le();
+    auto& x_builder = points_builder.content<Field_points::x>();
+    x_builder.append(m_x);
+    m_y = m__io->read_u4le();
+    auto& y_builder = points_builder.content<Field_points::y>();
+    y_builder.append(m_y);
+    m_z = m__io->read_u4le();
+    auto& z_builder = points_builder.content<Field_points::z>();
+    z_builder.append(m_z);
+}
+
+fake_t::point_t::~point_t() {
+    _clean_up();
+}
+
+void fake_t::point_t::_clean_up() {
+}
+
+
+extern "C" {
+
+  Result fill(const char* file_path) {
+    Result result;
+    std::string error_message;
+    LayoutBuilder* builder = load(file_path);
+
+    bool is_valid = builder->is_valid(error_message);
+    if (is_valid) {
+      result.builder = builder;
+      result.error_message = NULL;
+    }
+    else {
+      result.builder = NULL;
+      result.error_message = error_message.c_str();
+    }
+    return result;
+  }
+
+  void dump(void * buffer, int64_t size) {
+
+    uint8_t* data = reinterpret_cast<uint8_t*>(buffer);
+    for(int i = 0; i < size; i++) {
+      printf("%ld", (int64_t)(data[i]));
+    }
+    // LayoutBuilder* builder1 = reinterpret_cast<LayoutBuilder*>(builder);
+  }
+
+  const char* form(void* builder) {
+    return strdup(reinterpret_cast<LayoutBuilder*>(builder)->form().c_str());
+  }
+
+  int64_t length(void* builder) {
+    return reinterpret_cast<LayoutBuilder*>(builder)->length();
+  }
+
+  int64_t num_buffers(void* builder) {
+    return ::num_buffers_helper(reinterpret_cast<LayoutBuilder*>(builder));          
+  }
+
+  const char* buffer_name(void* builder, int64_t index) {
+    return ::buffer_name_helper(reinterpret_cast<LayoutBuilder*>(builder))[index].c_str();  
+  }
+
+  int64_t buffer_size(void* builder, int64_t index) {
+    return ::buffer_size_helper(reinterpret_cast<LayoutBuilder*>(builder))[index];
+  }
+
+  void copy_into(const char* name, void* from_builder, void* to_buffer, int64_t index) {
+    printf("printing copy_into function\n");
+    // printf("%s", name);
+    reinterpret_cast<LayoutBuilder*>(from_builder)->to_buffer(to_buffer, name);
+    // dump(to_buffer, buffer_size(from_builder, index));
+    printf("done copy_into function\n");
+  }
+
+  void deallocate(void* builder) {
+    reinterpret_cast<LayoutBuilder*>(builder)->clear();
+  }
+}
\ No newline at end of file
diff --git a/src-fake-test/fake.h b/src-fake-test/fake.h
new file mode 100644
index 0000000..181e2b9
--- /dev/null
+++ b/src-fake-test/fake.h
@@ -0,0 +1,187 @@
+#ifndef ANIMAL_H_
+#define ANIMAL_H_
+
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+#include "kaitai/kaitaistruct.h"
+#include <stdint.h>
+#include "LayoutBuilder.h"
+#include <vector>
+#include <fstream>
+#include <iostream>
+
+template <class NODE, class PRIMITIVE, class LENGTH>
+void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length) {
+  out << node << ": ";
+  for (size_t i = 0; i < length; i++) {
+    out << +ptr[i] << " ";
+  }
+  out << std::endl;
+}
+
+template<class NODE, class PRIMITIVE, class LENGTH, class ... Args>
+void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length, Args&&...args)
+{
+    dump(out, node, ptr, length);
+    dump(out, args...);
+}
+
+std::map<std::string, void*>
+inline empty_buffers(std::map<std::string, size_t> &names_nbytes) {
+  std::map<std::string, void*> buffers = {};
+  for(const auto& it : names_nbytes) {
+    auto* ptr = new uint8_t[it.second];
+    buffers[it.first] = (void*)ptr;
+  }
+  return buffers;
+}
+
+using UserDefinedMap = std::map<std::size_t, std::string>;
+template<class... BUILDERS>
+using RecordBuilder = awkward::LayoutBuilder::Record<UserDefinedMap, BUILDERS...>;
+template<std::size_t field_name, class BUILDER>
+using RecordField = awkward::LayoutBuilder::Field<field_name, BUILDER>;
+template<class PRIMITIVE, class BUILDER>
+using ListOffsetBuilder = awkward::LayoutBuilder::ListOffset<PRIMITIVE, BUILDER>;
+template<class PRIMITIVE>
+using NumpyBuilder = awkward::LayoutBuilder::Numpy<PRIMITIVE>;
+
+enum Field_fake : std::size_t {points};
+enum Field_points : std::size_t {x, y, z};
+
+using FakeBuilderType =
+	RecordBuilder<
+		RecordField<Field_fake::points, ListOffsetBuilder<int64_t, RecordBuilder<
+			RecordField<Field_points::x, NumpyBuilder<uint32_t>>,
+			RecordField<Field_points::y, NumpyBuilder<uint32_t>>,
+			RecordField<Field_points::z, NumpyBuilder<uint32_t>>
+		>>>
+	>;
+using PointsBuilderType = decltype(std::declval<FakeBuilderType>().content<Field_fake::points>().content());
+
+
+#if KAITAI_STRUCT_VERSION < 9000L
+#error "Incompatible Kaitai Struct C++/STL API: version 0.9 or later is required"
+#endif
+
+class fake_t : public kaitai::kstruct {
+
+public:
+    class point_t;
+
+    fake_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = 0, fake_t* p__root = 0);
+
+private:
+    void _read();
+    void _clean_up();
+
+public:
+    ~fake_t();
+
+    class point_t : public kaitai::kstruct {
+
+    public:
+
+        point_t(kaitai::kstream* p__io, fake_t* p__parent = 0, fake_t* p__root = 0);
+
+    private:
+        void _read();
+        void _clean_up();
+
+    public:
+        ~point_t();
+
+    private:
+        uint32_t m_x;
+        uint32_t m_y;
+        uint32_t m_z;
+        fake_t* m__root;
+        fake_t* m__parent;
+
+    public:
+        uint32_t x() const { return m_x; }
+        uint32_t y() const { return m_y; }
+        uint32_t z() const { return m_z; }
+        fake_t* _root() const { return m__root; }
+        fake_t* _parent() const { return m__parent; }
+        PointsBuilderType points_builder;
+    };
+
+private:
+    std::vector<point_t*>* m_points;
+    fake_t* m__root;
+    kaitai::kstruct* m__parent;
+
+public:
+    std::vector<point_t*>* points() const { return m_points; }
+    fake_t* _root() const { return m__root; }
+    kaitai::kstruct* _parent() const { return m__parent; }
+    FakeBuilderType fake_builder;
+};
+
+using LayoutBuilder = 
+    RecordBuilder<
+		RecordField<Field_fake::points, ListOffsetBuilder<int64_t, RecordBuilder<
+			RecordField<Field_points::x, NumpyBuilder<uint32_t>>,
+			RecordField<Field_points::y, NumpyBuilder<uint32_t>>,
+			RecordField<Field_points::z, NumpyBuilder<uint32_t>>
+		>>>
+	>;
+
+std::map<std::string, LayoutBuilder*> builderMap;
+
+LayoutBuilder* load(std::string file_path) {
+    std::ifstream infile(file_path, std::ifstream::binary);
+    kaitai::kstream ks(&infile);
+    
+    fake_t* obj = new fake_t(&ks);
+
+    builderMap[file_path] = &(obj->fake_builder);
+    std::map<std::string, void*> buffers = {};
+    std::map <std::string, size_t> names_nbytes = {};
+
+    builderMap[file_path]->buffer_nbytes(names_nbytes);
+
+    for (auto it: names_nbytes) {
+        uint8_t *ptr = new uint8_t[it.second];
+        buffers[it.first] = (void *) ptr; 
+    }
+
+    builderMap[file_path]->to_buffers(buffers);
+    
+    for(auto it: names_nbytes) {
+        std::cout << "printing buffer " << it.first << " and size " << it.second;
+        uint8_t* data = reinterpret_cast<uint8_t*>(buffers[it.first]);
+        std::cout << "data from builder" << std::endl;
+        for(int i = 0; i < it.second; i++)
+            std::cout << data[i] * 1 << " ";
+        std::cout << std::endl;
+    }
+    return builderMap[file_path];
+}
+
+extern "C" {
+
+  struct Result {
+    void* builder;
+    const char* error_message;
+  };
+
+  Result fill(const char* file_path);
+
+  const char* form(void* builder);
+
+  int64_t length(void* builder);
+
+  int64_t num_buffers(void* builder);
+
+  const char* buffer_name(void* builder, int64_t index);
+
+  int64_t buffer_size(void* builder, int64_t index);
+
+  void copy_into(const char* name, void* from_builder, void* to_buffer, int64_t index);
+
+  void deallocate(void* builder);
+}
+
+#endif  // FAKE_H_
diff --git a/src-fake-test/fake.py b/src-fake-test/fake.py
new file mode 100644
index 0000000..0e6c600
--- /dev/null
+++ b/src-fake-test/fake.py
@@ -0,0 +1,77 @@
+import ctypes
+import numpy as np
+import awkward as ak
+
+class Reader:
+    def __init__(self, library_path):
+        self.library_path = library_path
+        self.lib = ctypes.CDLL(library_path)
+
+    def load(self, file_path: str):
+        class Result(ctypes.Structure):
+            _fields_ = [
+                ("builder", ctypes.c_void_p),
+                ("error_message", ctypes.c_char_p),
+            ]
+
+        fill = self.lib.fill
+        fill.argtypes = [ctypes.c_char_p]
+        fill.restypes = Result
+
+        form = self.lib.form
+        form.argtypes = [ctypes.c_void_p]
+        form.restype = ctypes.c_char_p
+
+        length = self.lib.length
+        length.argtypes = [ctypes.c_void_p]
+        length.restype = ctypes.c_int64
+
+        num_buffers = self.lib.num_buffers
+        num_buffers.argtypes = [ctypes.c_void_p]
+        num_buffers.restype = ctypes.c_int64
+
+        buffer_name = self.lib.buffer_name
+        buffer_name.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+        buffer_name.restype = ctypes.c_char_p
+
+        buffer_size = self.lib.buffer_size
+        buffer_size.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+        buffer_size.restype = ctypes.c_int64
+
+        copy_into = self.lib.copy_into
+        copy_into.argtypes = [ctypes.c_char_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_int64]
+
+        deallocate = self.lib.deallocate
+        deallocate.argtypes = [ctypes.c_void_p]
+
+        dump = self.lib.dump
+        dump.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+
+        result = fill(file_path.encode('utf-8'))
+
+        builder_form = form(result).decode("utf-8")
+        builder_length = length(result)
+        num_buffers = num_buffers(result)
+        containers = {}
+
+        try:
+            for i in range(num_buffers):
+                name = buffer_name(result, i)
+                print(name)
+                size = buffer_size(result, i)
+                containers[name.decode('utf-8')] = np.empty(size, dtype=np.uint8)
+                pointer, read_only_flag = containers[name.decode('utf-8')].__array_interface__['data']
+                # dump(containers[name].ctypes.data_as(ctypes.POINTER(ctypes.c_void_p)), size)
+                copy_into(ctypes.c_char_p(name), result, pointer, i)
+                print(name)
+            print(containers)
+
+        finally:
+            deallocate(result)
+    
+        return ak.from_buffers(builder_form, builder_length, containers)
+
+fake = Reader("./libfake.so")
+array =  fake.load("data/fake.raw")
+
+print(array)
\ No newline at end of file
diff --git a/src-fake-test/fake.raw b/src-fake-test/fake.raw
new file mode 100644
index 0000000000000000000000000000000000000000..5a92db7c91ed68342952734dcee5e930497c7a71
GIT binary patch
literal 36000
zcmeIzAr62*3;@9%IIsjs!v8<XegZdQT~%|}Su?ZMUPoQ^)LD1EwaSeBcpLtOo8TU@
zfCVgI0Sj2b0v51<1uS3z3s}Gc7O;Q?EMNf(Sik}nuz&?DU;ztQzycPqfCVgI0Sj2b
z0v51<1uS3z3s}Gc7O;Q?EMNf(Sik}nuz&?DU;ztQzycPqfCVgI0Sj2b0v51<1uS3z
z3s}Gc7O;Q?EMNf(Sik}nuz&?DU;ztQzycPqfCVgI0Sj2b0v51<1uS3z3s}Gc7O;Q?
hEMNf(Sik}nuz&?DU;ztQzycPqfCVgI0So@O-~$#S1HS+O

literal 0
HcmV?d00001

diff --git a/src-fake-test/kaitai/custom_decoder.h b/src-fake-test/kaitai/custom_decoder.h
new file mode 100644
index 0000000..6da7f5f
--- /dev/null
+++ b/src-fake-test/kaitai/custom_decoder.h
@@ -0,0 +1,16 @@
+#ifndef KAITAI_CUSTOM_DECODER_H
+#define KAITAI_CUSTOM_DECODER_H
+
+#include <string>
+
+namespace kaitai {
+
+class custom_decoder {
+public:
+    virtual ~custom_decoder() {};
+    virtual std::string decode(std::string src) = 0;
+};
+
+}
+
+#endif
diff --git a/src-fake-test/kaitai/exceptions.h b/src-fake-test/kaitai/exceptions.h
new file mode 100644
index 0000000..729dc3e
--- /dev/null
+++ b/src-fake-test/kaitai/exceptions.h
@@ -0,0 +1,224 @@
+#ifndef KAITAI_EXCEPTIONS_H
+#define KAITAI_EXCEPTIONS_H
+
+#include "kaitaistream.h"
+
+#include <string>
+#include <stdexcept>
+
+// We need to use "noexcept" in virtual destructor of our exceptions
+// subclasses. Different compilers have different ideas on how to
+// achieve that: C++98 compilers prefer `throw()`, C++11 and later
+// use `noexcept`. We define KS_NOEXCEPT macro for that.
+
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
+#define KS_NOEXCEPT noexcept
+#else
+#define KS_NOEXCEPT throw()
+#endif
+
+namespace kaitai {
+
+/**
+ * Common ancestor for all errors related to `bytes_to_str` operation. Also used
+ * to signal misc non-specific `bytes_to_str` failures.
+ */
+class bytes_to_str_error: public std::runtime_error {
+public:
+    bytes_to_str_error(const std::string what):
+        std::runtime_error(std::string("bytes_to_str error: ") + what) {}
+
+    virtual ~bytes_to_str_error() KS_NOEXCEPT {};
+};
+
+/**
+ * Exception to signal that `bytes_to_str` operation was requested to use some encoding
+ * that is not available in given runtime environment.
+ */
+class unknown_encoding: public bytes_to_str_error {
+public:
+    unknown_encoding(const std::string enc_name):
+        bytes_to_str_error(std::string("unknown encoding: `") + enc_name + std::string("`")) {}
+
+    virtual ~unknown_encoding() KS_NOEXCEPT {};
+};
+
+/**
+ * Exception to signal that `bytes_to_str` operation failed to decode given byte sequence.
+ */
+class illegal_seq_in_encoding: public bytes_to_str_error {
+public:
+    illegal_seq_in_encoding(const std::string what):
+        bytes_to_str_error("illegal sequence: " + what) {}
+
+    virtual ~illegal_seq_in_encoding() KS_NOEXCEPT {};
+};
+
+/**
+ * Common ancestor for all error originating from Kaitai Struct usage.
+ * Stores KSY source path, pointing to an element supposedly guilty of
+ * an error.
+ */
+class kstruct_error: public std::runtime_error {
+public:
+    kstruct_error(const std::string what, const std::string src_path):
+        std::runtime_error(src_path + ": " + what),
+        m_src_path(src_path)
+    {
+    }
+
+    virtual ~kstruct_error() KS_NOEXCEPT {};
+
+protected:
+    const std::string m_src_path;
+};
+
+/**
+ * Error that occurs when default endianness should be decided with
+ * a switch, but nothing matches (although using endianness expression
+ * implies that there should be some positive result).
+ */
+class undecided_endianness_error: public kstruct_error {
+public:
+    undecided_endianness_error(const std::string src_path):
+        kstruct_error("unable to decide on endianness for a type", src_path)
+    {
+    }
+
+    virtual ~undecided_endianness_error() KS_NOEXCEPT {};
+};
+
+/**
+ * Common ancestor for all validation failures. Stores pointer to
+ * KaitaiStream IO object which was involved in an error.
+ */
+class validation_failed_error: public kstruct_error {
+public:
+    validation_failed_error(const std::string what, kstream* io, const std::string src_path):
+        kstruct_error("at pos " + kstream::to_string(io->pos()) + ": validation failed: " + what, src_path),
+        m_io(io)
+    {
+    }
+
+// "at pos #{io.pos}: validation failed: #{msg}"
+
+    virtual ~validation_failed_error() KS_NOEXCEPT {};
+
+protected:
+    kstream* m_io;
+};
+
+/**
+ * Signals validation failure: we required "actual" value to be equal to
+ * "expected", but it turned out that it's not.
+ */
+template<typename T>
+class validation_not_equal_error: public validation_failed_error {
+public:
+    validation_not_equal_error<T>(const T& expected, const T& actual, kstream* io, const std::string src_path):
+        validation_failed_error("not equal", io, src_path),
+        m_expected(expected),
+        m_actual(actual)
+    {
+    }
+
+    // "not equal, expected #{expected.inspect}, but got #{actual.inspect}"
+
+    virtual ~validation_not_equal_error<T>() KS_NOEXCEPT {};
+
+protected:
+    const T& m_expected;
+    const T& m_actual;
+};
+
+/**
+ * Signals validation failure: we required "actual" value to be greater
+ * than or equal to "min", but it turned out that it's not.
+ */
+template<typename T>
+class validation_less_than_error: public validation_failed_error {
+public:
+    validation_less_than_error<T>(const T& min, const T& actual, kstream* io, const std::string src_path):
+        validation_failed_error("not in range", io, src_path),
+        m_min(min),
+        m_actual(actual)
+    {
+    }
+
+    // "not in range, min #{min.inspect}, but got #{actual.inspect}"
+
+    virtual ~validation_less_than_error<T>() KS_NOEXCEPT {};
+
+protected:
+    const T& m_min;
+    const T& m_actual;
+};
+
+/**
+ * Signals validation failure: we required "actual" value to be less
+ * than or equal to "max", but it turned out that it's not.
+ */
+template<typename T>
+class validation_greater_than_error: public validation_failed_error {
+public:
+    validation_greater_than_error<T>(const T& max, const T& actual, kstream* io, const std::string src_path):
+        validation_failed_error("not in range", io, src_path),
+        m_max(max),
+        m_actual(actual)
+    {
+    }
+
+    // "not in range, max #{max.inspect}, but got #{actual.inspect}"
+
+    virtual ~validation_greater_than_error<T>() KS_NOEXCEPT {};
+
+protected:
+    const T& m_max;
+    const T& m_actual;
+};
+
+/**
+ * Signals validation failure: we required "actual" value to be from
+ * the list, but it turned out that it's not.
+ */
+template<typename T>
+class validation_not_any_of_error: public validation_failed_error {
+public:
+    validation_not_any_of_error<T>(const T& actual, kstream* io, const std::string src_path):
+        validation_failed_error("not any of the list", io, src_path),
+        m_actual(actual)
+    {
+    }
+
+    // "not any of the list, got #{actual.inspect}"
+
+    virtual ~validation_not_any_of_error<T>() KS_NOEXCEPT {};
+
+protected:
+    const T& m_actual;
+};
+
+/**
+ * Signals validation failure: we required "actual" value to match
+ * the expression, but it turned out that it doesn't.
+ */
+template<typename T>
+class validation_expr_error: public validation_failed_error {
+public:
+    validation_expr_error<T>(const T& actual, kstream* io, const std::string src_path):
+        validation_failed_error("not matching the expression", io, src_path),
+        m_actual(actual)
+    {
+    }
+
+    // "not matching the expression, got #{actual.inspect}"
+
+    virtual ~validation_expr_error<T>() KS_NOEXCEPT {};
+
+protected:
+    const T& m_actual;
+};
+
+}
+
+#endif
diff --git a/src-fake-test/kaitai/kaitaistream.cpp b/src-fake-test/kaitai/kaitaistream.cpp
new file mode 100644
index 0000000..eb00187
--- /dev/null
+++ b/src-fake-test/kaitai/kaitaistream.cpp
@@ -0,0 +1,877 @@
+#include "kaitai/kaitaistream.h"
+#include "exceptions.h"
+
+#if defined(__APPLE__)
+#include <machine/endian.h>
+#include <libkern/OSByteOrder.h>
+#define bswap_16(x) OSSwapInt16(x)
+#define bswap_32(x) OSSwapInt32(x)
+#define bswap_64(x) OSSwapInt64(x)
+#define __BYTE_ORDER    BYTE_ORDER
+#define __BIG_ENDIAN    BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#elif defined(_MSC_VER) // !__APPLE__
+#include <stdlib.h>
+#define __LITTLE_ENDIAN     1234
+#define __BIG_ENDIAN        4321
+#define __BYTE_ORDER        __LITTLE_ENDIAN
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+#elif defined(__QNX__) // __QNX__
+#include <sys/param.h>
+#include <gulliver.h>
+#define bswap_16(x) ENDIAN_RET16(x)
+#define bswap_32(x) ENDIAN_RET32(x)
+#define bswap_64(x) ENDIAN_RET64(x)
+#define __BYTE_ORDER    BYTE_ORDER
+#define __BIG_ENDIAN    BIG_ENDIAN
+#define __LITTLE_ENDIAN LITTLE_ENDIAN
+#else // !__APPLE__ or !_MSC_VER or !__QNX__
+#include <endian.h>
+#include <byteswap.h>
+#endif
+
+#include <iostream>
+#include <vector>
+#include <stdexcept>
+
+kaitai::kstream::kstream(std::istream *io) {
+    m_io = io;
+    init();
+}
+
+kaitai::kstream::kstream(const std::string &data) : m_io_str(data) {
+    m_io = &m_io_str;
+    init();
+}
+
+void kaitai::kstream::init() {
+    exceptions_enable();
+    align_to_byte();
+}
+
+void kaitai::kstream::close() {
+    //  m_io->close();
+}
+
+void kaitai::kstream::exceptions_enable() const {
+    m_io->exceptions(
+        std::istream::eofbit |
+        std::istream::failbit |
+        std::istream::badbit
+    );
+}
+
+// ========================================================================
+// Stream positioning
+// ========================================================================
+
+bool kaitai::kstream::is_eof() const {
+    if (m_bits_left > 0) {
+        return false;
+    }
+    char t;
+    m_io->exceptions(std::istream::badbit);
+    m_io->get(t);
+    if (m_io->eof()) {
+        m_io->clear();
+        exceptions_enable();
+        return true;
+    } else {
+        m_io->unget();
+        exceptions_enable();
+        return false;
+    }
+}
+
+void kaitai::kstream::seek(uint64_t pos) {
+    m_io->seekg(pos);
+}
+
+uint64_t kaitai::kstream::pos() {
+    return m_io->tellg();
+}
+
+uint64_t kaitai::kstream::size() {
+    std::iostream::pos_type cur_pos = m_io->tellg();
+    m_io->seekg(0, std::ios::end);
+    std::iostream::pos_type len = m_io->tellg();
+    m_io->seekg(cur_pos);
+    return len;
+}
+
+// ========================================================================
+// Integer numbers
+// ========================================================================
+
+// ------------------------------------------------------------------------
+// Signed
+// ------------------------------------------------------------------------
+
+int8_t kaitai::kstream::read_s1() {
+    char t;
+    m_io->get(t);
+    return t;
+}
+
+// ........................................................................
+// Big-endian
+// ........................................................................
+
+int16_t kaitai::kstream::read_s2be() {
+    int16_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 2);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_16(t);
+#endif
+    return t;
+}
+
+int32_t kaitai::kstream::read_s4be() {
+    int32_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 4);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_32(t);
+#endif
+    return t;
+}
+
+int64_t kaitai::kstream::read_s8be() {
+    int64_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 8);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_64(t);
+#endif
+    return t;
+}
+
+// ........................................................................
+// Little-endian
+// ........................................................................
+
+int16_t kaitai::kstream::read_s2le() {
+    int16_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 2);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_16(t);
+#endif
+    return t;
+}
+
+int32_t kaitai::kstream::read_s4le() {
+    int32_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 4);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_32(t);
+#endif
+    return t;
+}
+
+int64_t kaitai::kstream::read_s8le() {
+    int64_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 8);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_64(t);
+#endif
+    return t;
+}
+
+// ------------------------------------------------------------------------
+// Unsigned
+// ------------------------------------------------------------------------
+
+uint8_t kaitai::kstream::read_u1() {
+    char t;
+    m_io->get(t);
+    return t;
+}
+
+// ........................................................................
+// Big-endian
+// ........................................................................
+
+uint16_t kaitai::kstream::read_u2be() {
+    uint16_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 2);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_16(t);
+#endif
+    return t;
+}
+
+uint32_t kaitai::kstream::read_u4be() {
+    uint32_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 4);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_32(t);
+#endif
+    return t;
+}
+
+uint64_t kaitai::kstream::read_u8be() {
+    uint64_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 8);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_64(t);
+#endif
+    return t;
+}
+
+// ........................................................................
+// Little-endian
+// ........................................................................
+
+uint16_t kaitai::kstream::read_u2le() {
+    uint16_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 2);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_16(t);
+#endif
+    return t;
+}
+
+uint32_t kaitai::kstream::read_u4le() {
+    uint32_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 4);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_32(t);
+#endif
+    return t;
+}
+
+uint64_t kaitai::kstream::read_u8le() {
+    uint64_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 8);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_64(t);
+#endif
+    return t;
+}
+
+// ========================================================================
+// Floating point numbers
+// ========================================================================
+
+// ........................................................................
+// Big-endian
+// ........................................................................
+
+float kaitai::kstream::read_f4be() {
+    uint32_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 4);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_32(t);
+#endif
+    return reinterpret_cast<float &>(t);
+}
+
+double kaitai::kstream::read_f8be() {
+    uint64_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 8);
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+    t = bswap_64(t);
+#endif
+    return reinterpret_cast<double &>(t);
+}
+
+// ........................................................................
+// Little-endian
+// ........................................................................
+
+float kaitai::kstream::read_f4le() {
+    uint32_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 4);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_32(t);
+#endif
+    return reinterpret_cast<float &>(t);
+}
+
+double kaitai::kstream::read_f8le() {
+    uint64_t t;
+    m_io->read(reinterpret_cast<char *>(&t), 8);
+#if __BYTE_ORDER == __BIG_ENDIAN
+    t = bswap_64(t);
+#endif
+    return reinterpret_cast<double &>(t);
+}
+
+// ========================================================================
+// Unaligned bit values
+// ========================================================================
+
+void kaitai::kstream::align_to_byte() {
+    m_bits_left = 0;
+    m_bits = 0;
+}
+
+uint64_t kaitai::kstream::read_bits_int_be(int n) {
+    uint64_t res = 0;
+
+    int bits_needed = n - m_bits_left;
+    m_bits_left = -bits_needed & 7; // `-bits_needed mod 8`
+
+    if (bits_needed > 0) {
+        // 1 bit  => 1 byte
+        // 8 bits => 1 byte
+        // 9 bits => 2 bytes
+        int bytes_needed = ((bits_needed - 1) / 8) + 1; // `ceil(bits_needed / 8)`
+        if (bytes_needed > 8)
+            throw std::runtime_error("read_bits_int_be: more than 8 bytes requested");
+        uint8_t buf[8];
+        m_io->read(reinterpret_cast<char *>(buf), bytes_needed);
+        for (int i = 0; i < bytes_needed; i++) {
+            res = res << 8 | buf[i];
+        }
+
+        uint64_t new_bits = res;
+        res = res >> m_bits_left | (bits_needed < 64 ? m_bits << bits_needed : 0); // avoid undefined behavior of `x << 64`
+        m_bits = new_bits; // will be masked at the end of the function
+    } else {
+        res = m_bits >> -bits_needed; // shift unneeded bits out
+    }
+
+    uint64_t mask = (static_cast<uint64_t>(1) << m_bits_left) - 1; // `m_bits_left` is in range 0..7, so `(1 << 64)` does not have to be considered
+    m_bits &= mask;
+
+    return res;
+}
+
+// Deprecated, use read_bits_int_be() instead.
+uint64_t kaitai::kstream::read_bits_int(int n) {
+    return read_bits_int_be(n);
+}
+
+uint64_t kaitai::kstream::read_bits_int_le(int n) {
+    uint64_t res = 0;
+    int bits_needed = n - m_bits_left;
+
+    if (bits_needed > 0) {
+        // 1 bit  => 1 byte
+        // 8 bits => 1 byte
+        // 9 bits => 2 bytes
+        int bytes_needed = ((bits_needed - 1) / 8) + 1; // `ceil(bits_needed / 8)`
+        if (bytes_needed > 8)
+            throw std::runtime_error("read_bits_int_le: more than 8 bytes requested");
+        uint8_t buf[8];
+        m_io->read(reinterpret_cast<char *>(buf), bytes_needed);
+        for (int i = 0; i < bytes_needed; i++) {
+            res |= static_cast<uint64_t>(buf[i]) << (i * 8);
+        }
+
+        // NB: for bit shift operators in C++, "if the value of the right operand is
+        // negative or is greater or equal to the number of bits in the promoted left
+        // operand, the behavior is undefined." (see
+        // https://en.cppreference.com/w/cpp/language/operator_arithmetic#Bitwise_shift_operators)
+        // So we define our desired behavior here.
+        uint64_t new_bits = bits_needed < 64 ? res >> bits_needed : 0;
+        res = res << m_bits_left | m_bits;
+        m_bits = new_bits;
+    } else {
+        res = m_bits;
+        m_bits >>= n;
+    }
+
+    m_bits_left = -bits_needed & 7; // `-bits_needed mod 8`
+
+    if (n < 64) {
+        uint64_t mask = (static_cast<uint64_t>(1) << n) - 1;
+        res &= mask;
+    }
+    // if `n == 64`, do nothing
+    return res;
+}
+
+// ========================================================================
+// Byte arrays
+// ========================================================================
+
+std::string kaitai::kstream::read_bytes(std::streamsize len) {
+    std::vector<char> result(len);
+
+    // NOTE: streamsize type is signed, negative values are only *supposed* to not be used.
+    // http://en.cppreference.com/w/cpp/io/streamsize
+    if (len < 0) {
+        throw std::runtime_error("read_bytes: requested a negative amount");
+    }
+
+    if (len > 0) {
+        m_io->read(&result[0], len);
+    }
+
+    return std::string(result.begin(), result.end());
+}
+
+std::string kaitai::kstream::read_bytes_full() {
+    std::iostream::pos_type p1 = m_io->tellg();
+    m_io->seekg(0, std::ios::end);
+    std::iostream::pos_type p2 = m_io->tellg();
+    size_t len = p2 - p1;
+
+    // Note: this requires a std::string to be backed with a
+    // contiguous buffer. Officially, it's a only requirement since
+    // C++11 (C++98 and C++03 didn't have this requirement), but all
+    // major implementations had contiguous buffers anyway.
+    std::string result(len, ' ');
+    m_io->seekg(p1);
+    m_io->read(&result[0], len);
+
+    return result;
+}
+
+std::string kaitai::kstream::read_bytes_term(char term, bool include, bool consume, bool eos_error) {
+    std::string result;
+    std::getline(*m_io, result, term);
+    if (m_io->eof()) {
+        // encountered EOF
+        if (eos_error) {
+            throw std::runtime_error("read_bytes_term: encountered EOF");
+        }
+    } else {
+        // encountered terminator
+        if (include)
+            result.push_back(term);
+        if (!consume)
+            m_io->unget();
+    }
+    return result;
+}
+
+std::string kaitai::kstream::ensure_fixed_contents(std::string expected) {
+    std::string actual = read_bytes(expected.length());
+
+    if (actual != expected) {
+        // NOTE: I think printing it outright is not best idea, it could contain non-ASCII characters
+        // like backspace and beeps and whatnot. It would be better to print hexlified version, and
+        // also to redirect it to stderr.
+        throw std::runtime_error("ensure_fixed_contents: actual data does not match expected data");
+    }
+
+    return actual;
+}
+
+std::string kaitai::kstream::bytes_strip_right(std::string src, char pad_byte) {
+    std::size_t new_len = src.length();
+
+    while (new_len > 0 && src[new_len - 1] == pad_byte)
+        new_len--;
+
+    return src.substr(0, new_len);
+}
+
+std::string kaitai::kstream::bytes_terminate(std::string src, char term, bool include) {
+    std::size_t new_len = 0;
+    std::size_t max_len = src.length();
+
+    while (new_len < max_len && src[new_len] != term)
+        new_len++;
+
+    if (include && new_len < max_len)
+        new_len++;
+
+    return src.substr(0, new_len);
+}
+
+// ========================================================================
+// Byte array processing
+// ========================================================================
+
+std::string kaitai::kstream::process_xor_one(std::string data, uint8_t key) {
+    size_t len = data.length();
+    std::string result(len, ' ');
+
+    for (size_t i = 0; i < len; i++)
+        result[i] = data[i] ^ key;
+
+    return result;
+}
+
+std::string kaitai::kstream::process_xor_many(std::string data, std::string key) {
+    size_t len = data.length();
+    size_t kl = key.length();
+    std::string result(len, ' ');
+
+    size_t ki = 0;
+    for (size_t i = 0; i < len; i++) {
+        result[i] = data[i] ^ key[ki];
+        ki++;
+        if (ki >= kl)
+            ki = 0;
+    }
+
+    return result;
+}
+
+std::string kaitai::kstream::process_rotate_left(std::string data, int amount) {
+    size_t len = data.length();
+    std::string result(len, ' ');
+
+    for (size_t i = 0; i < len; i++) {
+        uint8_t bits = data[i];
+        result[i] = (bits << amount) | (bits >> (8 - amount));
+    }
+
+    return result;
+}
+
+#ifdef KS_ZLIB
+#include <zlib.h>
+
+std::string kaitai::kstream::process_zlib(std::string data) {
+    int ret;
+
+    unsigned char *src_ptr = reinterpret_cast<unsigned char *>(&data[0]);
+    std::stringstream dst_strm;
+
+    z_stream strm;
+    strm.zalloc = Z_NULL;
+    strm.zfree = Z_NULL;
+    strm.opaque = Z_NULL;
+
+    ret = inflateInit(&strm);
+    if (ret != Z_OK)
+        throw std::runtime_error("process_zlib: inflateInit error");
+
+    strm.next_in = src_ptr;
+    strm.avail_in = data.length();
+
+    unsigned char outbuffer[ZLIB_BUF_SIZE];
+    std::string outstring;
+
+    // get the decompressed bytes blockwise using repeated calls to inflate
+    do {
+        strm.next_out = reinterpret_cast<Bytef *>(outbuffer);
+        strm.avail_out = sizeof(outbuffer);
+
+        ret = inflate(&strm, 0);
+
+        if (outstring.size() < strm.total_out)
+            outstring.append(reinterpret_cast<char *>(outbuffer), strm.total_out - outstring.size());
+    } while (ret == Z_OK);
+
+    if (ret != Z_STREAM_END) { // an error occurred that was not EOF
+        std::ostringstream exc_msg;
+        exc_msg << "process_zlib: error #" << ret << "): " << strm.msg;
+        throw std::runtime_error(exc_msg.str());
+    }
+
+    if (inflateEnd(&strm) != Z_OK)
+        throw std::runtime_error("process_zlib: inflateEnd error");
+
+    return outstring;
+}
+#endif
+
+// ========================================================================
+// Misc utility methods
+// ========================================================================
+
+int kaitai::kstream::mod(int a, int b) {
+    if (b <= 0)
+        throw std::invalid_argument("mod: divisor b <= 0");
+    int r = a % b;
+    if (r < 0)
+        r += b;
+    return r;
+}
+
+#include <algorithm>
+void kaitai::kstream::unsigned_to_decimal(uint64_t number, char *buffer) {
+    // Implementation from https://ideone.com/nrQfA8 by Alf P. Steinbach
+    // (see https://www.zverovich.net/2013/09/07/integer-to-string-conversion-in-cplusplus.html#comment-1033931478)
+    if (number == 0) {
+        *buffer++ = '0';
+    } else {
+        char *p_first = buffer;
+        while (number != 0) {
+            *buffer++ = static_cast<char>('0' + number % 10);
+            number /= 10;
+        }
+        std::reverse(p_first, buffer);
+    }
+    *buffer = '\0';
+}
+
+int64_t kaitai::kstream::string_to_int(const std::string& str, int base) {
+    char *str_end;
+
+    errno = 0;
+    int64_t res = strtoll(str.c_str(), &str_end, base);
+
+    // Check for successful conversion and throw an exception if the entire string was not converted
+    if (str_end != str.c_str() + str.size()) {
+        throw std::invalid_argument("string_to_int");
+    }
+
+    if (errno == ERANGE) {
+        throw std::out_of_range("string_to_int");
+    }
+
+    return res;
+}
+
+std::string kaitai::kstream::reverse(std::string val) {
+    std::reverse(val.begin(), val.end());
+
+    return val;
+}
+
+uint8_t kaitai::kstream::byte_array_min(const std::string val) {
+    uint8_t min = 0xff; // UINT8_MAX
+    std::string::const_iterator end = val.end();
+    for (std::string::const_iterator it = val.begin(); it != end; ++it) {
+        uint8_t cur = static_cast<uint8_t>(*it);
+        if (cur < min) {
+            min = cur;
+        }
+    }
+    return min;
+}
+
+uint8_t kaitai::kstream::byte_array_max(const std::string val) {
+    uint8_t max = 0; // UINT8_MIN
+    std::string::const_iterator end = val.end();
+    for (std::string::const_iterator it = val.begin(); it != end; ++it) {
+        uint8_t cur = static_cast<uint8_t>(*it);
+        if (cur > max) {
+            max = cur;
+        }
+    }
+    return max;
+}
+
+// ========================================================================
+// Other internal methods
+// ========================================================================
+
+#ifndef KS_STR_DEFAULT_ENCODING
+#define KS_STR_DEFAULT_ENCODING "UTF-8"
+#endif
+
+#ifdef KS_STR_ENCODING_ICONV
+
+#include <iconv.h>
+#include <cerrno>
+#include <stdexcept>
+
+std::string kaitai::kstream::bytes_to_str(const std::string src, const char *src_enc) {
+    iconv_t cd = iconv_open(KS_STR_DEFAULT_ENCODING, src_enc);
+
+    if (cd == (iconv_t)-1) {
+        if (errno == EINVAL) {
+            throw unknown_encoding(src_enc);
+        } else {
+            throw bytes_to_str_error("error opening iconv");
+        }
+    }
+
+    size_t src_len = src.length();
+    size_t src_left = src_len;
+
+    // Start with a buffer length of double the source length.
+    size_t dst_len = src_len * 2;
+    std::string dst(dst_len, ' ');
+    size_t dst_left = dst_len;
+
+    // NB: this should be const char *, but for some reason iconv() requires non-const in its 2nd argument,
+    // so we force it with a cast.
+    char *src_ptr = const_cast<char*>(src.data());
+    char *dst_ptr = &dst[0];
+
+    while (true) {
+        size_t res = iconv(cd, &src_ptr, &src_left, &dst_ptr, &dst_left);
+
+        if (res == (size_t)-1) {
+            if (errno == E2BIG) {
+                // dst buffer is not enough to accomodate whole string
+                // enlarge the buffer and try again
+                size_t dst_used = dst_len - dst_left;
+                dst_left += dst_len;
+                dst_len += dst_len;
+                dst.resize(dst_len);
+
+                // dst.resize might have allocated destination buffer in another area
+                // of memory, thus our previous pointer "dst" will be invalid; re-point
+                // it using "dst_used".
+                dst_ptr = &dst[dst_used];
+            } else if (errno == EILSEQ) {
+                throw illegal_seq_in_encoding("EILSEQ");
+            } else if (errno == EINVAL) {
+                throw illegal_seq_in_encoding("EINVAL");
+            } else {
+                throw bytes_to_str_error(to_string(errno));
+            }
+        } else {
+            // conversion successful
+            dst.resize(dst_len - dst_left);
+            break;
+        }
+    }
+
+    if (iconv_close(cd) != 0) {
+        throw bytes_to_str_error("iconv close error");
+    }
+
+    return dst;
+}
+#elif defined(KS_STR_ENCODING_NONE)
+std::string kaitai::kstream::bytes_to_str(const std::string src, const char *src_enc) {
+    return src;
+}
+#elif defined(KS_STR_ENCODING_WIN32API)
+#include <windows.h>
+#include <limits>
+
+// Unbreak std::numeric_limits<T>::max, as otherwise MSVC substitutes "useful" max() macro.
+#undef max
+
+int kaitai::kstream::encoding_to_win_codepage(const char *src_enc) {
+    std::string enc(src_enc);
+    if (enc == "UTF-8") {
+        return CP_UTF8;
+    } else if (enc == "UTF-16LE") {
+        return KAITAI_CP_UTF16LE;
+    } else if (enc == "UTF-16BE") {
+        return KAITAI_CP_UTF16BE;
+    } else if (enc == "IBM437") {
+        return 437;
+    } else if (enc == "IBM850") {
+        return 850;
+    } else if (enc == "SHIFT_JIS") {
+        return 932;
+    } else if (enc == "GB2312") {
+        return 936;
+    } else if (enc == "ASCII") {
+        return 20127;
+    } else if (enc == "EUC-JP") {
+        return 20932;
+    } else if (enc == "ISO-8859-1") {
+        return 28591;
+    } else if (enc == "ISO-8859-2") {
+        return 28592;
+    } else if (enc == "ISO-8859-3") {
+        return 28593;
+    } else if (enc == "ISO-8859-4") {
+        return 28594;
+    } else if (enc == "ISO-8859-5") {
+        return 28595;
+    } else if (enc == "ISO-8859-6") {
+        return 28596;
+    } else if (enc == "ISO-8859-7") {
+        return 28597;
+    } else if (enc == "ISO-8859-8") {
+        return 28598;
+    } else if (enc == "ISO-8859-9") {
+        return 28599;
+    } else if (enc == "ISO-8859-10") {
+        return 28600;
+    } else if (enc == "ISO-8859-11") {
+        return 28601;
+    } else if (enc == "ISO-8859-13") {
+        return 28603;
+    } else if (enc == "ISO-8859-14") {
+        return 28604;
+    } else if (enc == "ISO-8859-15") {
+        return 28605;
+    } else if (enc == "ISO-8859-16") {
+        return 28606;
+    }
+
+    return KAITAI_CP_UNSUPPORTED;
+}
+
+std::string kaitai::kstream::bytes_to_str(const std::string src, const char *src_enc) {
+    // Step 1: convert encoding name to codepage number
+    int codepage = encoding_to_win_codepage(src_enc);
+    if (codepage == KAITAI_CP_UNSUPPORTED) {
+        throw unknown_encoding(src_enc);
+    }
+    return bytes_to_str(src, codepage);
+}
+
+std::string kaitai::kstream::bytes_to_str(const std::string src, int codepage) {
+    // Shortcut: if we're already in UTF-8, no need to convert anything
+    if (codepage == CP_UTF8) {
+        return src;
+    }
+
+    // Step 2: convert bytes to UTF-16 ("wide char") string
+    std::wstring utf16;
+    int32_t utf16_len;
+    int32_t src_len;
+    if (src.length() > std::numeric_limits<int32_t>::max()) {
+        throw bytes_to_str_error("buffers longer than int32_t are unsupported");
+    } else {
+        src_len = static_cast<int32_t>(src.length());
+    }
+
+    switch (codepage) {
+    case KAITAI_CP_UTF16LE:
+        // If our source is already UTF-16LE, just copy it
+
+        if (src_len % 2 != 0) {
+            throw illegal_seq_in_encoding("incomplete");
+        }
+
+        utf16_len = src_len / 2;
+        utf16 = std::wstring((wchar_t*)src.c_str(), utf16_len);
+        break;
+    case KAITAI_CP_UTF16BE:
+        // If our source is in UTF-16BE, convert it to UTF-16LE by swapping bytes
+
+        if (src_len % 2 != 0) {
+            throw illegal_seq_in_encoding("incomplete");
+        }
+
+        utf16_len = src_len / 2;
+
+        utf16 = std::wstring(utf16_len, L'\0');
+        for (int32_t i = 0; i < utf16_len; i++) {
+            utf16[i] = (static_cast<uint8_t>(src[i * 2]) << 8) | static_cast<uint8_t>(src[i * 2 + 1]);
+        }
+        break;
+    default:
+        // Calculate the length of the UTF-16 string
+        utf16_len = MultiByteToWideChar(codepage, 0, src.c_str(), src_len, 0, 0);
+        if (utf16_len == 0) {
+            throw bytes_to_str_error("MultiByteToWideChar length calculation error");
+        }
+
+        // Convert to UTF-16 string
+        utf16 = std::wstring(utf16_len, L'\0');
+        if (MultiByteToWideChar(codepage, MB_ERR_INVALID_CHARS, src.c_str(), src_len, &utf16[0], utf16_len) == 0) {
+            auto err = GetLastError();
+            if (err == ERROR_NO_UNICODE_TRANSLATION) {
+                throw illegal_seq_in_encoding("MultiByteToWideChar");
+            } else {
+                throw bytes_to_str_error("MultiByteToWideChar conversion error");
+            }
+        }
+    }
+
+    // Step 3: convert UTF-16 string to UTF-8 string
+
+    // Calculate the length of the UTF-8 string
+    int utf8_len = WideCharToMultiByte(CP_UTF8, 0, &utf16[0], utf16_len, 0, 0, 0, 0);
+    if (utf8_len == 0) {
+        throw bytes_to_str_error("WideCharToMultiByte length calculation error");
+    }
+
+    // Convert to UTF-8 string
+    std::string utf8(utf8_len, '\0');
+    if (WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, &utf16[0], utf16_len, &utf8[0], utf8_len, 0, 0) == 0) {
+        auto err = GetLastError();
+        if (err == ERROR_NO_UNICODE_TRANSLATION) {
+            throw illegal_seq_in_encoding("WideCharToMultiByte");
+        } else {
+            throw bytes_to_str_error("WideCharToMultiByte conversion error");
+        }
+    }
+
+    return utf8;
+}
+
+#else
+#error Need to decide how to handle strings: please define one of: KS_STR_ENCODING_ICONV, KS_STR_ENCODING_WIN32API, KS_STR_ENCODING_NONE
+#endif
diff --git a/src-fake-test/kaitai/kaitaistream.h b/src-fake-test/kaitai/kaitaistream.h
new file mode 100644
index 0000000..3523ed1
--- /dev/null
+++ b/src-fake-test/kaitai/kaitaistream.h
@@ -0,0 +1,374 @@
+#ifndef KAITAI_STREAM_H
+#define KAITAI_STREAM_H
+
+// Kaitai Struct runtime API version: x.y.z = 'xxxyyyzzz' decimal
+#define KAITAI_STRUCT_VERSION 10000L
+
+#include <istream>
+#include <sstream>
+#include <stdint.h>
+#include <sys/types.h>
+#include <limits>
+#include <stdexcept>
+#include <errno.h>
+
+namespace kaitai {
+
+/**
+ * Kaitai Stream class (kaitai::kstream) is an implementation of
+ * <a href="https://doc.kaitai.io/stream_api.html">Kaitai Struct stream API</a>
+ * for C++/STL. It's implemented as a wrapper over generic STL std::istream.
+ *
+ * It provides a wide variety of simple methods to read (parse) binary
+ * representations of primitive types, such as integer and floating
+ * point numbers, byte arrays and strings, and also provides stream
+ * positioning / navigation methods with unified cross-language and
+ * cross-toolkit semantics.
+ *
+ * Typically, end users won't access Kaitai Stream class manually, but would
+ * describe a binary structure format using .ksy language and then would use
+ * Kaitai Struct compiler to generate source code in desired target language.
+ * That code, in turn, would use this class and API to do the actual parsing
+ * job.
+ */
+class kstream {
+public:
+    /**
+     * Constructs new Kaitai Stream object, wrapping a given std::istream.
+     * \param io istream object to use for this Kaitai Stream
+     */
+    kstream(std::istream* io);
+
+    /**
+     * Constructs new Kaitai Stream object, wrapping a given in-memory data
+     * buffer.
+     * \param data data buffer to use for this Kaitai Stream
+     */
+    kstream(const std::string& data);
+
+    void close();
+
+    /** @name Stream positioning */
+    //@{
+    /**
+     * Check if stream pointer is at the end of stream. Note that the semantics
+     * are different from traditional STL semantics: one does *not* need to do a
+     * read (which will fail) after the actual end of the stream to trigger EOF
+     * flag, which can be accessed after that read. It is sufficient to just be
+     * at the end of the stream for this method to return true.
+     * \return "true" if we are located at the end of the stream.
+     */
+    bool is_eof() const;
+
+    /**
+     * Set stream pointer to designated position.
+     * \param pos new position (offset in bytes from the beginning of the stream)
+     */
+    void seek(uint64_t pos);
+
+    /**
+     * Get current position of a stream pointer.
+     * \return pointer position, number of bytes from the beginning of the stream
+     */
+    uint64_t pos();
+
+    /**
+     * Get total size of the stream in bytes.
+     * \return size of the stream in bytes
+     */
+    uint64_t size();
+    //@}
+
+    /** @name Integer numbers */
+    //@{
+
+    // ------------------------------------------------------------------------
+    // Signed
+    // ------------------------------------------------------------------------
+
+    int8_t read_s1();
+
+    // ........................................................................
+    // Big-endian
+    // ........................................................................
+
+    int16_t read_s2be();
+    int32_t read_s4be();
+    int64_t read_s8be();
+
+    // ........................................................................
+    // Little-endian
+    // ........................................................................
+
+    int16_t read_s2le();
+    int32_t read_s4le();
+    int64_t read_s8le();
+
+    // ------------------------------------------------------------------------
+    // Unsigned
+    // ------------------------------------------------------------------------
+
+    uint8_t read_u1();
+
+    // ........................................................................
+    // Big-endian
+    // ........................................................................
+
+    uint16_t read_u2be();
+    uint32_t read_u4be();
+    uint64_t read_u8be();
+
+    // ........................................................................
+    // Little-endian
+    // ........................................................................
+
+    uint16_t read_u2le();
+    uint32_t read_u4le();
+    uint64_t read_u8le();
+
+    //@}
+
+    /** @name Floating point numbers */
+    //@{
+
+    // ........................................................................
+    // Big-endian
+    // ........................................................................
+
+    float read_f4be();
+    double read_f8be();
+
+    // ........................................................................
+    // Little-endian
+    // ........................................................................
+
+    float read_f4le();
+    double read_f8le();
+
+    //@}
+
+    /** @name Unaligned bit values */
+    //@{
+
+    void align_to_byte();
+    uint64_t read_bits_int_be(int n);
+    uint64_t read_bits_int(int n);
+    uint64_t read_bits_int_le(int n);
+
+    //@}
+
+    /** @name Byte arrays */
+    //@{
+
+    std::string read_bytes(std::streamsize len);
+    std::string read_bytes_full();
+    std::string read_bytes_term(char term, bool include, bool consume, bool eos_error);
+    std::string ensure_fixed_contents(std::string expected);
+
+    static std::string bytes_strip_right(std::string src, char pad_byte);
+    static std::string bytes_terminate(std::string src, char term, bool include);
+    static std::string bytes_to_str(const std::string src, const char *src_enc);
+
+    //@}
+
+    /** @name Byte array processing */
+    //@{
+
+    /**
+     * Performs a XOR processing with given data, XORing every byte of input with a single
+     * given value.
+     * @param data data to process
+     * @param key value to XOR with
+     * @return processed data
+     */
+    static std::string process_xor_one(std::string data, uint8_t key);
+
+    /**
+     * Performs a XOR processing with given data, XORing every byte of input with a key
+     * array, repeating key array many times, if necessary (i.e. if data array is longer
+     * than key array).
+     * @param data data to process
+     * @param key array of bytes to XOR with
+     * @return processed data
+     */
+    static std::string process_xor_many(std::string data, std::string key);
+
+    /**
+     * Performs a circular left rotation shift for a given buffer by a given amount of bits,
+     * using groups of 1 bytes each time. Right circular rotation should be performed
+     * using this procedure with corrected amount.
+     * @param data source data to process
+     * @param amount number of bits to shift by
+     * @return copy of source array with requested shift applied
+     */
+    static std::string process_rotate_left(std::string data, int amount);
+
+#ifdef KS_ZLIB
+    /**
+     * Performs an unpacking ("inflation") of zlib-compressed data with usual zlib headers.
+     * @param data data to unpack
+     * @return unpacked data
+     * @throws IOException
+     */
+    static std::string process_zlib(std::string data);
+#endif
+
+    //@}
+
+    /**
+     * Performs modulo operation between two integers: dividend `a`
+     * and divisor `b`. Divisor `b` is expected to be positive. The
+     * result is always 0 <= x <= b - 1.
+     */
+    static int mod(int a, int b);
+
+    /**
+     * Converts given integer `val` to a decimal string representation.
+     * Should be used in place of std::to_string() (which is available only
+     * since C++11) in older C++ implementations.
+     */
+    template<typename I>
+// check for C++11 support - https://stackoverflow.com/a/40512515
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1900)
+    // https://stackoverflow.com/a/27913885
+    typename std::enable_if<
+            std::is_integral<I>::value &&
+            // check if we don't have something too large like GCC's `__int128_t`
+            std::numeric_limits<I>::max() >= 0 &&
+            std::numeric_limits<I>::max() <= std::numeric_limits<uint64_t>::max(),
+            std::string
+    >::type
+#else
+    std::string
+#endif
+    static to_string(I val) {
+        // in theory, `digits10 + 3` would be enough (minus sign + leading digit
+        // + null terminator), but let's add a little more to be safe
+        char buf[std::numeric_limits<I>::digits10 + 5];
+        if (val < 0) {
+            buf[0] = '-';
+
+            // NB: `val` is negative and we need to get its absolute value (i.e. minus `val`). However, since
+            // `int64_t` uses two's complement representation, its range is `[-2**63, 2**63 - 1] =
+            // [-0x8000_0000_0000_0000, 0x7fff_ffff_ffff_ffff]` (both ends inclusive) and thus the naive
+            // `-val` operation will overflow for `val = std::numeric_limits<int64_t>::min() =
+            // -0x8000_0000_0000_0000` (because the result of `-val` is mathematically
+            // `-(-0x8000_0000_0000_0000) = 0x8000_0000_0000_0000`, but the `int64_t` type can represent at
+            // most `0x7fff_ffff_ffff_ffff`). And signed integer overflow is undefined behavior in C++.
+            //
+            // To avoid undefined behavior for `val = -0x8000_0000_0000_0000 = -2**63`, we do the following
+            // steps for all negative `val`s:
+            //
+            // 1. Convert the signed (and negative) `val` to an unsigned `uint64_t` type. This is a
+            //    well-defined operation in C++: the resulting `uint64_t` value will be `val mod 2**64` (`mod`
+            //    is modulo). The maximum `val` we can have here is `-1` (because `val < 0`), a theoretical
+            //    minimum we are able to support would be `-2**64 + 1 = -0xffff_ffff_ffff_ffff` (even though
+            //    in practice the widest standard type is `int64_t` with the minimum of `-2**63`):
+            //
+            //    * `static_cast<uint64_t>(-1) = -1 mod 2**64 = 2**64 + (-1) = 0xffff_ffff_ffff_ffff = 2**64 - 1`
+            //    * `static_cast<uint64_t>(-2**64 + 1) = (-2**64 + 1) mod 2**64 = 2**64 + (-2**64 + 1) = 1`
+            //
+            // 2. Subtract `static_cast<uint64_t>(val)` from `2**64 - 1 = 0xffff_ffff_ffff_ffff`. Since
+            //    `static_cast<uint64_t>(val)` is in range `[1, 2**64 - 1]` (see step 1), the result of this
+            //    subtraction will be mathematically in range `[0, (2**64 - 1) - 1] = [0, 2**64 - 2]`. So the
+            //    mathematical result cannot be negative, hence this unsigned integer subtraction can never
+            //    wrap around (which wouldn't be a good thing to rely upon because it confuses programmers and
+            //    code analysis tools).
+            //
+            // 3. Since we did mathematically `(2**64 - 1) - (2**64 + val) = -val - 1` so far (and we wanted
+            //    to do `-val`), we add `1` to correct that. From step 2 we know that the result of `-val - 1`
+            //    is in range `[0, 2**64 - 2]`, so adding `1` will not wrap (at most we could get `2**64 - 1 =
+            //    0xffff_ffff_ffff_ffff`, which is still in the valid range of `uint64_t`).
+
+            unsigned_to_decimal((std::numeric_limits<uint64_t>::max() - static_cast<uint64_t>(val)) + 1, &buf[1]);
+        } else {
+            unsigned_to_decimal(val, buf);
+        }
+        return std::string(buf);
+    }
+
+    /**
+     * Converts string `str` to an integer value. Throws an exception if the
+     * string is not a valid integer.
+     *
+     * This one is supposed to mirror `std::stoll()` (which is available only
+     * since C++11) in older C++ implementations.
+     *
+     * Major difference between standard `std::stoll()` and `string_to_int()`
+     * is that this one does not perform any partial conversions and always
+     * throws `std::invalid_argument` if the string is not a valid integer.
+     *
+     * @param str String to convert
+     * @param base Base of the integer (default: 10)
+     * @throws std::invalid_argument if the string is not a valid integer
+     * @throws std::out_of_range if the integer is out of range
+     * @return Integer value of the string
+     */
+    static int64_t string_to_int(const std::string& str, int base = 10);
+
+    /**
+     * Reverses given string `val`, so that the first character becomes the
+     * last and the last one becomes the first. This should be used to avoid
+     * the need of local variables at the caller.
+     */
+    static std::string reverse(std::string val);
+
+    /**
+     * Finds the minimal byte in a byte array, treating bytes as
+     * unsigned values.
+     * @param val byte array to scan
+     * @return minimal byte in byte array as integer
+     */
+    static uint8_t byte_array_min(const std::string val);
+
+    /**
+     * Finds the maximal byte in a byte array, treating bytes as
+     * unsigned values.
+     * @param val byte array to scan
+     * @return maximal byte in byte array as integer
+     */
+    static uint8_t byte_array_max(const std::string val);
+
+private:
+    std::istream* m_io;
+    std::istringstream m_io_str;
+    int m_bits_left;
+    uint64_t m_bits;
+
+    void init();
+    void exceptions_enable() const;
+
+    static void unsigned_to_decimal(uint64_t number, char *buffer);
+
+#ifdef KS_STR_ENCODING_WIN32API
+    enum {
+        KAITAI_CP_UNSUPPORTED = -1,
+        KAITAI_CP_UTF16LE = -2,
+        KAITAI_CP_UTF16BE = -3,
+    };
+
+    /**
+     * Converts string name of the encoding into a Windows codepage number. We extend standard Windows codepage list
+     * with a few special meanings (see KAITAI_CP_* enum), reserving negative values of integer for that.
+     * @param src_enc string name of the encoding; this should match canonical name of the encoding as per discussion
+     *     in https://github.com/kaitai-io/kaitai_struct/issues/116
+     * @return Windows codepage number or member of KAITAI_CP_* enum.
+     * @ref https://learn.microsoft.com/en-us/windows/win32/intl/code-page-identifiers
+     */
+    static int encoding_to_win_codepage(const char *src_enc);
+
+    /**
+     * Converts bytes packed in std::string into a UTF-8 string, based on given source encoding indicated by `codepage`.
+     * @param src bytes to be converted
+     * @param codepage Windows codepage number or member of KAITAI_CP_* enum.
+     * @return UTF-8 string
+     */
+    static std::string bytes_to_str(const std::string src, int codepage);
+#endif
+
+    static const int ZLIB_BUF_SIZE = 128 * 1024;
+};
+
+}
+
+#endif
diff --git a/src-fake-test/kaitai/kaitaistruct.h b/src-fake-test/kaitai/kaitaistruct.h
new file mode 100644
index 0000000..7b5acd6
--- /dev/null
+++ b/src-fake-test/kaitai/kaitaistruct.h
@@ -0,0 +1,20 @@
+#ifndef KAITAI_STRUCT_H
+#define KAITAI_STRUCT_H
+
+#include "kaitaistream.h"
+
+namespace kaitai {
+
+class kstruct {
+public:
+    kstruct(kstream *_io) { m__io = _io; }
+    virtual ~kstruct() {}
+protected:
+    kstream *m__io;
+public:
+    kstream *_io() { return m__io; }
+};
+
+}
+
+#endif
diff --git a/src-fake-test/utils.h b/src-fake-test/utils.h
new file mode 100644
index 0000000..929c137
--- /dev/null
+++ b/src-fake-test/utils.h
@@ -0,0 +1,275 @@
+// BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
+
+#ifndef AWKWARD_CPP_HEADERS_UTILS_H_
+#define AWKWARD_CPP_HEADERS_UTILS_H_
+
+#include <iterator>
+#include <iostream>
+#include <complex>
+#include <type_traits>
+#include <cassert>
+#include <utility>
+#include <stdexcept>
+#include <stdint.h>
+#include <typeinfo>
+
+
+namespace awkward {
+
+  // FIXME:
+  // The following helper variable templates are part of C++17,
+  // define it ourselves until we switch to it
+  template< class T >
+  constexpr bool is_integral_v = std::is_integral<T>::value;
+
+  template< class T >
+  constexpr bool is_signed_v = std::is_signed<T>::value;
+
+  template< class T, class U >
+  constexpr bool is_same_v = std::is_same<T, U>::value;
+
+  /// @brief Returns the name of a primitive type as a string.
+  template <typename T>
+  inline const std::string
+  type_to_name() {
+    if (is_integral_v<T>) {
+      if (is_signed_v<T>) {
+        if (sizeof(T) == 1) {
+          return "int8";
+        }
+        else if (sizeof(T) == 2) {
+          return "int16";
+        }
+        else if (sizeof(T) == 4) {
+          return "int32";
+        }
+        else if (sizeof(T) == 8) {
+          return "int64";
+        }
+      }
+      else {
+        if (sizeof(T) == 1) {
+          return "uint8";
+        }
+        else if (sizeof(T) == 2) {
+          return "uint16";
+        }
+        else if (sizeof(T) == 4) {
+          return "uint32";
+        }
+        else if (sizeof(T) == 8) {
+          return "uint64";
+        }
+      }
+    }
+    else if (is_same_v<T, float>) {
+      return "float32";
+    }
+    else if (is_same_v<T, double>) {
+      return "float64";
+    }
+    else if (is_same_v<T, std::complex<float>>) {
+      return "complex64";
+    }
+    else if (is_same_v<T, std::complex<double>>) {
+      return "complex128";
+    }
+
+    // std::is_integral_v<T> and sizeof(T) not in (1, 2, 4, 8) can get here.
+    // Don't connect this line with the above as an 'else' clause.
+    return std::string("unsupported primitive type: ") + typeid(T).name();
+  }
+
+  template <>
+  inline const std::string
+  type_to_name<bool>() {
+    // This takes precedence over the unspecialized template, and therefore any
+    // 8-bit data that is not named bool will be mapped to "int8" or "uint8".
+    return "bool";
+  }
+
+  template <>
+  inline const std::string
+  type_to_name<char>() {
+    // This takes precedence over the unspecialized template, and therefore any
+    // 8-bit data that is not named char will be mapped to "int8" or "uint8".
+    return "char";
+  }
+
+
+  /// @brief Returns `char` string when the primitive type
+  /// is a character.
+  template <typename T>
+  inline const std::string
+  type_to_numpy_like() {
+    return type_to_name<T>();
+  }
+
+  /// @brief Returns numpy-like character code of a primitive
+  /// type as a string.
+  template <>
+  inline const std::string
+  type_to_numpy_like<uint8_t>() {
+    return "u8";
+  }
+
+  /// @brief Returns numpy-like character code `i8`, when the
+  /// primitive type is an 8-bit signed integer.
+  template <>
+  inline const std::string
+  type_to_numpy_like<int8_t>() {
+    return "i8";
+  }
+
+  /// @brief Returns numpy-like character code `u32`, when the
+  /// primitive type is a 32-bit unsigned integer.
+  template <>
+  inline const std::string
+  type_to_numpy_like<uint32_t>() {
+    return "u32";
+  }
+
+  /// @brief Returns numpy-like character code `i32`, when the
+  /// primitive type is a 32-bit signed integer.
+  template <>
+  inline const std::string
+  type_to_numpy_like<int32_t>() {
+    return "i32";
+  }
+
+  /// @brief Returns numpy-like character code `i64`, when the
+  /// primitive type is a 64-bit signed integer.
+  template <>
+  inline const std::string
+  type_to_numpy_like<int64_t>() {
+    return "i64";
+  }
+
+  template <typename, typename = void>
+  constexpr bool is_iterable{};
+
+  // FIXME:
+  // std::void_t is part of C++17, define it ourselves until we switch to it
+  template <typename...>
+  struct voider {
+    using type = void;
+  };
+
+  template <typename... T>
+  using void_t = typename voider<T...>::type;
+
+  template <typename T>
+  constexpr bool is_iterable<T,
+                             void_t<decltype(std::declval<T>().begin()),
+                                    decltype(std::declval<T>().end())>> = true;
+
+  template <typename Test, template <typename...> class Ref>
+  struct is_specialization : std::false_type {};
+
+  template <template <typename...> class Ref, typename... Args>
+  struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
+
+  /// @brief Generates a Form, which is a unique description of the
+  /// Layout Builder and its contents in the form of a JSON-like string.
+  ///
+  /// Used in RDataFrame to generate the form of the Numpy Layout Builder
+  /// and ListOffset Layout Builder.
+  template <typename T, typename OFFSETS>
+  std::string
+  type_to_form(int64_t form_key_id) {
+    if (std::string(typeid(T).name()).find("awkward") != std::string::npos) {
+      return std::string("awkward type");
+    }
+
+    std::stringstream form_key;
+    form_key << "node" << (form_key_id++);
+
+    if (std::is_arithmetic<T>::value) {
+      std::string parameters(type_to_name<T>() + "\", ");
+      if (std::is_same<T, char>::value) {
+        parameters = std::string(
+            "uint8\", \"parameters\": { \"__array__\": \"char\" }, ");
+      }
+      return "{\"class\": \"NumpyArray\", \"primitive\": \"" + parameters +
+             "\"form_key\": \"" + form_key.str() + "\"}";
+    } else if (is_specialization<T, std::complex>::value) {
+      return "{\"class\": \"NumpyArray\", \"primitive\": \"" +
+             type_to_name<T>() + "\", \"form_key\": \"" + form_key.str() +
+             "\"}";
+    }
+
+    typedef typename T::value_type value_type;
+
+    if (is_iterable<T>) {
+      std::string parameters("");
+      if (std::is_same<value_type, char>::value) {
+        parameters =
+            std::string(" \"parameters\": { \"__array__\": \"string\" }, ");
+      }
+      return "{\"class\": \"ListOffsetArray\", \"offsets\": \"" +
+             type_to_numpy_like<OFFSETS>() + "\", "
+             "\"content\":" +
+             type_to_form<value_type, OFFSETS>(form_key_id) + ", " + parameters +
+             "\"form_key\": \"" + form_key.str() + "\"}";
+    }
+    return "unsupported type";
+  }
+
+  /// @brief Check if an RDataFrame column is an Awkward Array.
+  template <typename T>
+  bool
+  is_awkward_type() {
+    return (std::string(typeid(T).name()).find("awkward") != std::string::npos);
+  }
+
+  /// @class visit_impl
+  ///
+  /// @brief Class to index tuple at runtime.
+  ///
+  /// @tparam INDEX Index of the tuple contents.
+  template <size_t INDEX>
+  struct visit_impl {
+    /// @brief Accesses the tuple contents at `INDEX` and
+    /// calls the given function on it.
+    ///
+    /// @tparam CONTENT Type of tuple content.
+    /// @tparam FUNCTION Function to be called on the tuple content.
+    template <typename CONTENT, typename FUNCTION>
+    static void
+    visit(CONTENT& contents, size_t index, FUNCTION fun) {
+      if (index == INDEX - 1) {
+        fun(std::get<INDEX - 1>(contents));
+      } else {
+        visit_impl<INDEX - 1>::visit(contents, index, fun);
+      }
+    }
+  };
+
+  /// @brief `INDEX` reached `0`, which means the runtime index did not
+  /// exist in the tuple.
+  template <>
+  struct visit_impl<0> {
+    template <typename CONTENT, typename FUNCTION>
+    static void
+    visit(CONTENT& /* contents */, size_t /* index */, FUNCTION /* fun */) {
+      assert(false);
+    }
+  };
+
+  /// @brief Visits the tuple contents at `index`.
+  template <typename FUNCTION, typename... CONTENTs>
+  void
+  visit_at(std::tuple<CONTENTs...> const& contents, size_t index, FUNCTION fun) {
+    visit_impl<sizeof...(CONTENTs)>::visit(contents, index, fun);
+  }
+
+  /// @brief Visits the tuple contents at `index`.
+  template <typename FUNCTION, typename... CONTENTs>
+  void
+  visit_at(std::tuple<CONTENTs...>& contents, size_t index, FUNCTION fun) {
+    visit_impl<sizeof...(CONTENTs)>::visit(contents, index, fun);
+  }
+
+}  // namespace awkward
+
+#endif  // AWKWARD_CPP_HEADERS_UTILS_H_

From 9dda771d104bc1ac765065678c6179b907e58710 Mon Sep 17 00:00:00 2001
From: Manasvi Goyal <mg.manasvi@gmail.com>
Date: Fri, 20 Oct 2023 12:20:16 +0200
Subject: [PATCH 2/3] Fix the data path in python

---
 src-fake-test/fake.py | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src-fake-test/fake.py b/src-fake-test/fake.py
index 0e6c600..dcb6c7f 100644
--- a/src-fake-test/fake.py
+++ b/src-fake-test/fake.py
@@ -2,6 +2,8 @@
 import numpy as np
 import awkward as ak
 
+print("start")
+
 class Reader:
     def __init__(self, library_path):
         self.library_path = library_path
@@ -57,21 +59,18 @@ class Result(ctypes.Structure):
         try:
             for i in range(num_buffers):
                 name = buffer_name(result, i)
-                print(name)
                 size = buffer_size(result, i)
                 containers[name.decode('utf-8')] = np.empty(size, dtype=np.uint8)
                 pointer, read_only_flag = containers[name.decode('utf-8')].__array_interface__['data']
-                # dump(containers[name].ctypes.data_as(ctypes.POINTER(ctypes.c_void_p)), size)
                 copy_into(ctypes.c_char_p(name), result, pointer, i)
-                print(name)
             print(containers)
 
         finally:
             deallocate(result)
     
         return ak.from_buffers(builder_form, builder_length, containers)
-
+    
 fake = Reader("./libfake.so")
-array =  fake.load("data/fake.raw")
+array =  fake.load("example_data/data/fake.raw")
 
 print(array)
\ No newline at end of file

From 59ad7b10878f96794cb9f9e87c2ccb2e42a0679b Mon Sep 17 00:00:00 2001
From: Manasvi Goyal <mg.manasvi@gmail.com>
Date: Fri, 20 Oct 2023 14:15:50 +0200
Subject: [PATCH 3/3] Cleaned up the debugging code

---
 src-fake-test/GrowableBuffer.h |  2 --
 src-fake-test/LayoutBuilder.h  | 49 +--------------------------------
 src-fake-test/fake.cpp         | 13 ---------
 src-fake-test/fake.h           | 50 +---------------------------------
 src-fake-test/fake.py          |  7 -----
 5 files changed, 2 insertions(+), 119 deletions(-)

diff --git a/src-fake-test/GrowableBuffer.h b/src-fake-test/GrowableBuffer.h
index 6d5b7b8..1daf83c 100644
--- a/src-fake-test/GrowableBuffer.h
+++ b/src-fake-test/GrowableBuffer.h
@@ -150,8 +150,6 @@ namespace awkward {
       if (next_) {
         next_->concatenate_to(to_ptr, offset + length_);
       }
-      for(int i = 0; i < 10; i++)
-        std::cout << ptr_[i] << "  ";
     }
 
     /// @brief Fills (one panel) GrowableBuffer<TO_PRIMITIVE> with the
diff --git a/src-fake-test/LayoutBuilder.h b/src-fake-test/LayoutBuilder.h
index e80086d..249e847 100644
--- a/src-fake-test/LayoutBuilder.h
+++ b/src-fake-test/LayoutBuilder.h
@@ -19,53 +19,6 @@
 
 namespace {
 
-template <class NODE, class PRIMITIVE, class LENGTH>
-void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length) {
-  out << node << ": ";
-  for (size_t i = 0; i < length; i++) {
-    out << +ptr[i] << " ";
-  }
-  out << std::endl;
-}
-
-template<class NODE, class PRIMITIVE, class LENGTH, class ... Args>
-void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length, Args&&...args)
-{
-    dump(out, node, ptr, length);
-    dump(out, args...);
-}
-
-std::map<std::string, void*>
-inline empty_buffers(std::map<std::string, size_t> &names_nbytes) {
-  std::map<std::string, void*> buffers = {};
-  for(const auto& it : names_nbytes) {
-    auto* ptr = new uint8_t[it.second];
-    buffers[it.first] = (void*)ptr;
-  }
-  return buffers;
-}
-
-  /// @brief Helper function to retrieve the buffers.
-  template<typename LayoutBuilder>
-  std::vector<uint8_t*> to_buffer_helper(const LayoutBuilder* builder) {
-    std::map <std::string, size_t> names_nbytes = {};
-    std::vector <uint8_t*> buffer_array;
-    builder->buffer_nbytes(names_nbytes);
-
-    std::map<std::string, void *> buffers = {};
-    for (auto it: names_nbytes) {
-        uint8_t *ptr = new uint8_t[it.second];
-        buffers[it.first] = (void *) ptr;
-    }
-
-    builder->to_buffers(buffers);
-
-    for (auto it: buffers) {
-      buffer_array.push_back(reinterpret_cast<uint8_t*>(it.second));
-    }
-    return buffer_array;
-  }
-
   /// @brief Helper function to retrieve the names of the buffers.
   template<typename LayoutBuilder>
   std::vector<std::string> buffer_name_helper(const LayoutBuilder* builder) {
@@ -270,7 +223,7 @@ namespace awkward {
         }
       }
 
-    // private:
+    private:
       /// @brief Buffer of `PRIMITIVE` type.
       awkward::GrowableBuffer<PRIMITIVE> data_;
 
diff --git a/src-fake-test/fake.cpp b/src-fake-test/fake.cpp
index 34e46fb..895b44d 100644
--- a/src-fake-test/fake.cpp
+++ b/src-fake-test/fake.cpp
@@ -106,15 +106,6 @@ extern "C" {
     return result;
   }
 
-  void dump(void * buffer, int64_t size) {
-
-    uint8_t* data = reinterpret_cast<uint8_t*>(buffer);
-    for(int i = 0; i < size; i++) {
-      printf("%ld", (int64_t)(data[i]));
-    }
-    // LayoutBuilder* builder1 = reinterpret_cast<LayoutBuilder*>(builder);
-  }
-
   const char* form(void* builder) {
     return strdup(reinterpret_cast<LayoutBuilder*>(builder)->form().c_str());
   }
@@ -136,11 +127,7 @@ extern "C" {
   }
 
   void copy_into(const char* name, void* from_builder, void* to_buffer, int64_t index) {
-    printf("printing copy_into function\n");
-    // printf("%s", name);
     reinterpret_cast<LayoutBuilder*>(from_builder)->to_buffer(to_buffer, name);
-    // dump(to_buffer, buffer_size(from_builder, index));
-    printf("done copy_into function\n");
   }
 
   void deallocate(void* builder) {
diff --git a/src-fake-test/fake.h b/src-fake-test/fake.h
index 181e2b9..50abc98 100644
--- a/src-fake-test/fake.h
+++ b/src-fake-test/fake.h
@@ -10,32 +10,6 @@
 #include <fstream>
 #include <iostream>
 
-template <class NODE, class PRIMITIVE, class LENGTH>
-void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length) {
-  out << node << ": ";
-  for (size_t i = 0; i < length; i++) {
-    out << +ptr[i] << " ";
-  }
-  out << std::endl;
-}
-
-template<class NODE, class PRIMITIVE, class LENGTH, class ... Args>
-void dump(std::ostringstream& out, NODE&& node, PRIMITIVE&& ptr, LENGTH&& length, Args&&...args)
-{
-    dump(out, node, ptr, length);
-    dump(out, args...);
-}
-
-std::map<std::string, void*>
-inline empty_buffers(std::map<std::string, size_t> &names_nbytes) {
-  std::map<std::string, void*> buffers = {};
-  for(const auto& it : names_nbytes) {
-    auto* ptr = new uint8_t[it.second];
-    buffers[it.first] = (void*)ptr;
-  }
-  return buffers;
-}
-
 using UserDefinedMap = std::map<std::size_t, std::string>;
 template<class... BUILDERS>
 using RecordBuilder = awkward::LayoutBuilder::Record<UserDefinedMap, BUILDERS...>;
@@ -133,30 +107,8 @@ std::map<std::string, LayoutBuilder*> builderMap;
 LayoutBuilder* load(std::string file_path) {
     std::ifstream infile(file_path, std::ifstream::binary);
     kaitai::kstream ks(&infile);
-    
     fake_t* obj = new fake_t(&ks);
-
-    builderMap[file_path] = &(obj->fake_builder);
-    std::map<std::string, void*> buffers = {};
-    std::map <std::string, size_t> names_nbytes = {};
-
-    builderMap[file_path]->buffer_nbytes(names_nbytes);
-
-    for (auto it: names_nbytes) {
-        uint8_t *ptr = new uint8_t[it.second];
-        buffers[it.first] = (void *) ptr; 
-    }
-
-    builderMap[file_path]->to_buffers(buffers);
-    
-    for(auto it: names_nbytes) {
-        std::cout << "printing buffer " << it.first << " and size " << it.second;
-        uint8_t* data = reinterpret_cast<uint8_t*>(buffers[it.first]);
-        std::cout << "data from builder" << std::endl;
-        for(int i = 0; i < it.second; i++)
-            std::cout << data[i] * 1 << " ";
-        std::cout << std::endl;
-    }
+    builderMap[file_path] = &(obj->fake_builder);  
     return builderMap[file_path];
 }
 
diff --git a/src-fake-test/fake.py b/src-fake-test/fake.py
index dcb6c7f..17e5016 100644
--- a/src-fake-test/fake.py
+++ b/src-fake-test/fake.py
@@ -2,8 +2,6 @@
 import numpy as np
 import awkward as ak
 
-print("start")
-
 class Reader:
     def __init__(self, library_path):
         self.library_path = library_path
@@ -46,9 +44,6 @@ class Result(ctypes.Structure):
         deallocate = self.lib.deallocate
         deallocate.argtypes = [ctypes.c_void_p]
 
-        dump = self.lib.dump
-        dump.argtypes = [ctypes.c_void_p, ctypes.c_int64]
-
         result = fill(file_path.encode('utf-8'))
 
         builder_form = form(result).decode("utf-8")
@@ -63,8 +58,6 @@ class Result(ctypes.Structure):
                 containers[name.decode('utf-8')] = np.empty(size, dtype=np.uint8)
                 pointer, read_only_flag = containers[name.decode('utf-8')].__array_interface__['data']
                 copy_into(ctypes.c_char_p(name), result, pointer, i)
-            print(containers)
-
         finally:
             deallocate(result)