LayoutBuilder.h

Go to the documentation of this file.

// BSD 3-Clause License; see https://github.com/scikit-hep/awkward/blob/main/LICENSE
 
#ifndef AWKWARD_LAYOUTBUILDER_H_
#define AWKWARD_LAYOUTBUILDER_H_
 
#include "awkward/BuilderOptions.h"
#include "awkward/GrowableBuffer.h"
#include "awkward/utils.h"
 
#include <map>
#include <algorithm>
#include <tuple>
#include <string>
#include <functional>
 
#define AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS awkward::BuilderOptions(1024, 1)
 
namespace awkward {
 
  namespace LayoutBuilder {
 
    class BuilderSetId {
    public:
        BuilderSetId(size_t& id) : id_(id) {}
 
        template <class CONTENT>
        void operator()(CONTENT& content) {
            content.builder.set_id(id_);
        }
 
    private:
        size_t& id_;
    };
 
    template <std::size_t ENUM, typename BUILDER>
    class Field {
    public:
      using Builder = BUILDER;
 
      std::string
      index_as_field() const {
        return std::to_string(index);
      }
 
      const std::size_t index = ENUM;
      Builder builder;
    };
 
    template <typename PRIMITIVE>
    class Numpy {
    public:
      Numpy()
          : data_(
                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
        size_t id = 0;
        set_id(id);
      }
 
      Numpy(const awkward::BuilderOptions& options)
          : data_(awkward::GrowableBuffer<PRIMITIVE>(options)) {
        size_t id = 0;
        set_id(id);
      }
 
      void
      append(PRIMITIVE x) noexcept {
        data_.append(x);
      }
 
      void
      extend(PRIMITIVE* ptr, size_t size) noexcept {
        data_.extend(ptr, size);
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
      }
 
      void
      clear() noexcept {
         data_.clear();
      }
 
      size_t
      length() const noexcept {
        return data_.length();
      }
 
      bool
      is_valid(std::string& /* error */) const noexcept {
        return true;
      }
 
      void
      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
          noexcept {
        names_nbytes["node" + std::to_string(id_) + "-data"] = data_.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));
        }
      }
 
      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"]));
      }
 
      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:
      awkward::GrowableBuffer<PRIMITIVE> data_;
 
      std::string parameters_;
 
      size_t id_;
    };
 
    template <typename PRIMITIVE, typename BUILDER>
    class ListOffset {
    public:
      ListOffset()
          : offsets_(
                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
        offsets_.append(0);
        size_t id = 0;
        set_id(id);
      }
 
      ListOffset(const awkward::BuilderOptions& options)
          : offsets_(awkward::GrowableBuffer<PRIMITIVE>(options)) {
        offsets_.append(0);
        size_t id = 0;
        set_id(id);
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      BUILDER&
      begin_list() noexcept {
        return content_;
      }
 
      void
      end_list() noexcept {
        offsets_.append(content_.length());
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        offsets_.clear();
        offsets_.append(0);
        content_.clear();
      }
 
      size_t
      length() const noexcept {
        return offsets_.length() - 1;
      }
 
      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);
        }
      }
 
      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);
      }
 
      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);
      }
 
      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);
      }
 
      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:
      GrowableBuffer<PRIMITIVE> offsets_;
 
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
    };
 
    template<class PRIMITIVE>
    class String : public ListOffset<PRIMITIVE, Numpy<uint8_t>> {
      public:
          String() : ListOffset<PRIMITIVE, Numpy<uint8_t>>() {
      this->set_parameters(R"""("__array__": "string")""");
      this->content().set_parameters(R"""("__array__": "char")""");
    }
 
      void append(const std::string& value) {
          this->begin_list();
          for (const auto& c: value) {
              this->content().append(c);
          }
          this->end_list();
      }
    };
 
    class Empty {
    public:
      Empty() {
        size_t id = 0;
        set_id(id);
      }
 
      void
      set_id(size_t& /* id */) noexcept {}
 
      void
      clear() noexcept {}
 
      size_t
      length() const noexcept {
        return 0;
      }
 
      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 {}
 
      void
      to_buffer(void* /* buffer */, const char* /* name */) const noexcept {}
 
      void
      to_char_buffers(std::map<std::string, uint8_t*>& /* buffers */) const noexcept {}
 
      std::string
      form() const noexcept {
        return "{ \"class\": \"EmptyArray\" }";
      }
 
    private:
      size_t id_;
    };
 
 
    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>;
 
      Record() {
        size_t id = 0;
        set_id(id);
        map_fields(std::index_sequence_for<BUILDERS...>());
      }
 
      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);
      }
 
      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;
        }
      }
 
      void
      set_fields(MAP user_defined_field_id_to_name_map) noexcept {
        content_names_ = user_defined_field_id_to_name_map;
      }
 
      template <std::size_t INDEX>
      typename RecordFieldType<INDEX>::Builder&
      content() noexcept {
        return std::get<INDEX>(contents).builder;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void set_id(size_t& id) noexcept {
 
          id_ = id;
          id++;
 
          BuilderSetId bsi(id);
          for (size_t i = 0; i < fields_count_; i++) {
 
              visit_at(contents, i, bsi);  // Here the functor will propagate `id`
          }
      }
 
      class ClearBuilder {
      public:
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.builder.clear();
          }
      };
 
      void
      clear() noexcept {
          ClearBuilder clearBuilder; // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, clearBuilder); // pass the functor instead of a lambda
          }
      }
      size_t
      length() const noexcept {
        return (std::get<0>(contents).builder.length());
      }
 
      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>());
      }
 
      class BufferNBytesFunctor {
      public:
          // Constructor to capture names_nbytes by reference
          BufferNBytesFunctor(std::map<std::string, size_t>& names_nbytes)
              : names_nbytes_(names_nbytes) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.builder.buffer_nbytes(names_nbytes_);
          }
 
      private:
          std::map<std::string, size_t>& names_nbytes_;  // reference to the map
      };
 
      void
      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const noexcept {
          BufferNBytesFunctor bufferNBytesFunctor(names_nbytes); // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, bufferNBytesFunctor); // pass the functor instead of the lambda
          }
      }
 
      class ToBuffersFunctor {
      public:
          // Constructor to capture buffers by reference
          ToBuffersFunctor(std::map<std::string, void*>& buffers)
              : buffers_(buffers) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.builder.to_buffers(buffers_);
          }
 
      private:
          std::map<std::string, void*>& buffers_;  // reference to the map
      };
 
      void
      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
          ToBuffersFunctor toBuffersFunctor(buffers); // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, toBuffersFunctor); // pass the functor instead of the lambda
          }
      }
      class ToBufferFunctor {
      public:
          // Constructor to capture buffer and name by reference
          ToBufferFunctor(void* buffer, const char* name)
              : buffer_(buffer), name_(name) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.builder.to_buffer(buffer_, name_);
          }
 
      private:
          void* buffer_;            // reference to buffer
          const char* name_;        // reference to name
      };
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
          ToBufferFunctor toBufferFunctor(buffer, name); // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, toBufferFunctor); // pass the functor instead of the lambda
          }
      }
 
 
      class ToCharBuffersFunctor {
      public:
          // Constructor to capture buffers by reference
          ToCharBuffersFunctor(std::map<std::string, uint8_t*>& buffers)
              : buffers_(buffers) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.builder.to_char_buffers(buffers_);
          }
 
      private:
          std::map<std::string, uint8_t*>& buffers_;  // reference to the buffers map
      };
 
      void
      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
          ToCharBuffersFunctor toCharBuffersFunctor(buffers); // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, toCharBuffersFunctor); // pass the functor instead of the lambda
          }
      }
 
 
      class ContentsFormFunctor {
      public:
          // Modify the constructor to accept a std::map instead of a std::vector
          ContentsFormFunctor(std::stringstream& out, const std::map<size_t, std::string>& content_names)
              : out_(out), content_names_(content_names) {}
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              size_t index = content.index;  // Assuming CONTENT has an index
              auto it = content_names_.find(index); // Lookup content name in the map
 
              if (it != content_names_.end()) {
                  out_ << "\"" << it->second << "\": ";
              } else {
                  out_ << "\"" << index << "\": "; // Fallback to index if not found
              }
 
              out_ << content.builder.form();
          }
 
      private:
          std::stringstream& out_;
          const std::map<size_t, std::string>& content_names_;  // Store the map by reference
      };
 
 
      std::string form() const noexcept {
          std::stringstream form_key;
          form_key << "node" << id_;
 
          std::string params("");
          if (!parameters_.empty()) {
              params = "\"parameters\": { " + parameters_ + " }, ";
          }
 
          std::stringstream out;
          out << "{ \"class\": \"RecordArray\", \"contents\": { ";
 
          for (size_t i = 0; i < fields_count_; i++) {
              if (i != 0) {
                  out << ", ";
              }
              ContentsFormFunctor contentsFormFunctor(out, content_names_);
              visit_at(contents, i, contentsFormFunctor);
          }
 
          out << " }, ";
          out << params << "\"form_key\": \"" << form_key.str() << "\" }";
          return out.str();
      }
 
      RecordContents contents;
 
    private:
      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())...});
      }
 
      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()...});
      }
 
      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)...});
      }
 
      std::vector<std::string> fields_;
 
      UserDefinedMap content_names_;
 
      std::string parameters_;
 
      size_t id_;
 
      static constexpr size_t fields_count_ = sizeof...(BUILDERS);
    };
 
    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:
      Tuple() {
        size_t id = 0;
        set_id(id);
      }
 
      template <std::size_t INDEX>
      TupleContentType<INDEX>&
      content() noexcept {
        return std::get<INDEX>(contents);
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      class SetIdFunctor {
      public:
          // Constructor to capture id by reference
          SetIdFunctor(size_t& id) : id_(id) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.set_id(id_);
          }
 
      private:
          size_t& id_;  // reference to the id
      };
 
      void
      set_id(size_t& id) noexcept {
          id_ = id;
          id++;
          SetIdFunctor setIdFunctor(id);  // instantiate the functor with id reference
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, setIdFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ClearFunctor {
      public:
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.clear();
          }
      };
      void
      clear() noexcept {
          ClearFunctor clearFunctor;  // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, clearFunctor);  // pass the functor instead of the lambda
          }
      }
 
      size_t
      length() const noexcept {
        return (std::get<0>(contents).length());
      }
 
      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>());
      }
 
      class BufferNBytesFunctor {
      public:
          // Constructor to capture names_nbytes by reference
          BufferNBytesFunctor(std::map<std::string, size_t>& names_nbytes)
              : names_nbytes_(names_nbytes) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.buffer_nbytes(names_nbytes_);
          }
 
      private:
          std::map<std::string, size_t>& names_nbytes_;  // reference to the map
      };
 
      void
      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const noexcept {
          BufferNBytesFunctor bufferNBytesFunctor(names_nbytes);  // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, bufferNBytesFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ToBuffersFunctor {
      public:
          // Constructor to capture buffers by reference
          ToBuffersFunctor(std::map<std::string, void*>& buffers)
              : buffers_(buffers) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.to_buffers(buffers_);
          }
 
      private:
          std::map<std::string, void*>& buffers_;  // reference to the buffers map
      };
 
      void
      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
          ToBuffersFunctor toBuffersFunctor(buffers);  // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, toBuffersFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ToBufferFunctor {
      public:
          // Constructor to capture buffer and name by reference
          ToBufferFunctor(void* buffer, const char* name)
              : buffer_(buffer), name_(name) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.to_buffer(buffer_, name_);
          }
 
      private:
          void* buffer_;            // reference to the buffer
          const char* name_;        // reference to the name
      };
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
          ToBufferFunctor toBufferFunctor(buffer, name);  // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, toBufferFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ToCharBuffersFunctor {
      public:
          // Constructor to capture buffers by reference
          ToCharBuffersFunctor(std::map<std::string, uint8_t*>& buffers)
              : buffers_(buffers) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.to_char_buffers(buffers_);
          }
 
      private:
          std::map<std::string, uint8_t*>& buffers_;  // reference to the buffers map
      };
 
      void
      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
          ToCharBuffersFunctor toCharBuffersFunctor(buffers);  // instantiate the functor
          for (size_t i = 0; i < fields_count_; i++) {
              visit_at(contents, i, toCharBuffersFunctor);  // pass the functor instead of the lambda
          }
      }
 
      class ContentsFormFunctor {
      public:
          ContentsFormFunctor(std::stringstream& out)
              : out_(out) {}
 
          // Template operator() to handle each content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              out_ << content.form();
          }
 
      private:
          std::stringstream& out_;  // Reference to the output stringstream
      };
 
 
      std::string
      form() const noexcept {
          std::stringstream form_key;
          form_key << "node" << id_;
          std::string params("");
          if (!parameters_.empty()) {
              params = "\"parameters\": { " + parameters_ + " }, ";
          }
          std::stringstream out;
          out << "{ \"class\": \"RecordArray\", \"contents\": [";
          for (size_t i = 0; i < fields_count_; i++) {
              if (i != 0) {
                  out << ", ";
              }
              ContentsFormFunctor contentsFormFunctor(out);
              visit_at(contents, i, contentsFormFunctor);
          }
          out << "], ";
          out << params << "\"form_key\": \"" << form_key.str() << "\" }";
          return out.str();
      }
 
      TupleContents contents;
 
    private:
      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()...});
      }
 
      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)...});
      }
 
      std::vector<int64_t> field_index_;
 
      std::string parameters_;
 
      size_t id_;
 
      static constexpr size_t fields_count_ = sizeof...(BUILDERS);
    };
 
    template <unsigned SIZE, typename BUILDER>
    class Regular {
    public:
      Regular() : length_(0) {
        size_t id = 0;
        set_id(id);
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      BUILDER&
      begin_list() noexcept {
        return content_;
      }
 
      void
      end_list() noexcept {
        length_++;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        length_ = 0;
        content_.clear();
      }
 
      size_t
      length() const noexcept {
        return length_;
      }
 
      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);
        }
      }
 
      void
      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
          noexcept {
        content_.buffer_nbytes(names_nbytes);
      }
 
      void
      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
        content_.to_buffers(buffers);
      }
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
        content_.to_buffer(buffer, name);
      }
 
      void
      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
        content_.to_char_buffers(buffers);
      }
 
      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:
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
 
      size_t length_;
 
      size_t size_ = SIZE;
    };
 
 
    template <typename PRIMITIVE, typename BUILDER>
    class Indexed {
    public:
      Indexed()
          : index_(
                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)),
            max_index_(0) {
        size_t id = 0;
        set_id(id);
      }
 
      Indexed(const awkward::BuilderOptions& options)
          : index_(awkward::GrowableBuffer<PRIMITIVE>(options)),
            max_index_(0) {
        size_t id = 0;
        set_id(id);
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      BUILDER&
      append_index() noexcept {
        return append_index(content_.length());
      }
 
      BUILDER&
      append_index(size_t i) noexcept {
        index_.append(i);
        if (i > max_index_) {
          max_index_ = i;
        } else if (i < 0) {
          max_index_ = UINTMAX_MAX;
        }
        return content_;
      }
 
      BUILDER&
      extend_index(size_t size) noexcept {
        size_t start = content_.length();
        size_t stop = start + size;
        if (stop - 1 > max_index_) {
          max_index_ = stop - 1;
        }
        for (size_t i = start; i < stop; i++) {
          index_.append(i);
        }
        return content_;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        max_index_ = 0;
        index_.clear();
        content_.clear();
      }
 
      size_t
      length() const noexcept {
        return index_.length();
      }
 
      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);
      }
 
      bool
      is_valid(std::string& error) const noexcept {
 
        if (max_index_ == UINTMAX_MAX) {
          std::stringstream out;
          out << "Indexed node" << id_ << " has a negative index\n";
          error.append(out.str());
          return false;
        } else if ((content_.length() == 0) && (max_index_ == 0)) { // catches empty object
        } else if (max_index_ >= content_.length()) {
          std::stringstream out;
          out << "Indexed node" << id_ << " has index " << max_index_
              << " but content has length "
              << content_.length() << "\n";
          error.append(out.str());
          return false;
        }
        return content_.is_valid(error);
      }
 
      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);
      }
 
      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);
      }
 
      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\": \"IndexedArray\", \"index\": \"" +
               type_to_numpy_like<PRIMITIVE>() +
               "\", \"content\": " + content_.form() + params +
               ", \"form_key\": \"" + form_key.str() + "\" }";
      }
 
    private:
      GrowableBuffer<PRIMITIVE> index_;
 
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
 
      size_t max_index_;
    };
 
    template <typename PRIMITIVE, typename BUILDER>
    class IndexedOption {
    public:
      IndexedOption()
          : index_(
                awkward::GrowableBuffer<PRIMITIVE>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)),
            last_valid_(-1),
            max_index_(0) {
        size_t id = 0;
        set_id(id);
      }
 
      IndexedOption(const awkward::BuilderOptions& options)
          : index_(awkward::GrowableBuffer<PRIMITIVE>(options)),
            last_valid_(-1),
            max_index_(0) {
        size_t id = 0;
        set_id(id);
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      BUILDER&
      append_valid() noexcept {
        last_valid_ = content_.length();
        return append_valid(last_valid_);
      }
 
      BUILDER&
      append_valid(size_t i) noexcept {
        last_valid_ = content_.length();
        index_.append(i);
        if (i > max_index_) {
          max_index_ = i;
        }
        return content_;
      }
 
      BUILDER&
      extend_valid(size_t size) noexcept {
        size_t start = content_.length();
        size_t stop = start + size;
        last_valid_ = stop - 1;
        if (last_valid_ > max_index_) {
          max_index_ = last_valid_;
        }
        for (size_t i = start; i < stop; i++) {
          index_.append(i);
        }
        return content_;
      }
 
      void
      append_invalid() noexcept {
        index_.append(-1);
      }
 
      void
      extend_invalid(size_t size) noexcept {
        for (size_t i = 0; i < size; i++) {
          index_.append(-1);
        }
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        last_valid_ = -1;
        index_.clear();
        content_.clear();
      }
 
      size_t
      length() const noexcept {
        return index_.length();
      }
 
      bool
      is_valid(std::string& error) const noexcept {
        if ((content_.length() == 0) && (max_index_ == 0)) { // catches empty object
        } else if (max_index_ >= content_.length()) {
          std::stringstream out;
          out << "IndexedOption node" << id_ << " has index " << max_index_
              << " but content has length "
              << content_.length() << "\n";
          error.append(out.str());
 
          return false;
        }
        return content_.is_valid(error);
      }
 
      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);
      }
 
      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);
      }
 
      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);
      }
 
      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:
      GrowableBuffer<PRIMITIVE> index_;
 
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
 
      size_t last_valid_;
 
      size_t max_index_;
    };
 
    template <typename BUILDER>
    class Unmasked {
    public:
      Unmasked() {
        size_t id = 0;
        set_id(id);
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        content_.clear();
      }
 
      size_t
      length() const noexcept {
        return content_.length();
      }
 
      bool
      is_valid(std::string& error) const noexcept {
        return content_.is_valid(error);
      }
 
      void
      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const
          noexcept {
        content_.buffer_nbytes(names_nbytes);
      }
 
      void
      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
        content_.to_buffers(buffers);
      }
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
        content_.to_buffer(buffer, name);
      }
 
      void
      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
        content_.to_char_buffers(buffers);
      }
 
      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:
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
    };
 
    template <bool VALID_WHEN, typename BUILDER>
    class ByteMasked {
    public:
      ByteMasked()
          : mask_(awkward::GrowableBuffer<int8_t>(AWKWARD_LAYOUTBUILDER_DEFAULT_OPTIONS)) {
        size_t id = 0;
        set_id(id);
      }
 
      ByteMasked(const awkward::BuilderOptions& options)
          : mask_(awkward::GrowableBuffer<int8_t>(options)) {
        size_t id = 0;
        set_id(id);
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      bool
      valid_when() const noexcept {
        return valid_when_;
      }
 
      BUILDER&
      append_valid() noexcept {
        mask_.append(valid_when_);
        return content_;
      }
 
      BUILDER&
      extend_valid(size_t size) noexcept {
        for (size_t i = 0; i < size; i++) {
          mask_.append(valid_when_);
        }
        return content_;
      }
 
      BUILDER&
      append_invalid() noexcept {
        mask_.append(!valid_when_);
        return content_;
      }
 
      BUILDER&
      extend_invalid(size_t size) noexcept {
        for (size_t i = 0; i < size; i++) {
          mask_.append(!valid_when_);
        }
        return content_;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        mask_.clear();
        content_.clear();
      }
 
      size_t
      length() const noexcept {
        return mask_.length();
      }
 
      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);
        }
      }
 
      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);
      }
 
      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);
      }
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
        if (std::string(name) == std::string("node" + std::to_string(id_) + "-mask")) {
          mask_.concatenate(reinterpret_cast<int8_t*>(buffer));
        }
        content_.to_buffer(buffer, name);
      }
 
      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);
      }
 
      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:
      GrowableBuffer<int8_t> mask_;
 
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
 
      bool valid_when_ = VALID_WHEN;
    };
 
    template <bool VALID_WHEN, bool LSB_ORDER, typename BUILDER>
    class BitMasked {
    public:
      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;
          }
        }
      }
 
      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;
          }
        }
      }
 
      BUILDER&
      content() noexcept {
        return content_;
      }
 
      bool
      valid_when() const noexcept {
        return valid_when_;
      }
 
      bool
      lsb_order() const noexcept {
        return lsb_order_;
      }
 
      BUILDER&
      append_valid() noexcept {
        append_begin();
        current_byte_ |= cast_[current_index_];
        append_end();
        return content_;
      }
 
      BUILDER&
      extend_valid(size_t size) noexcept {
        for (size_t i = 0; i < size; i++) {
          append_valid();
        }
        return content_;
      }
 
      BUILDER&
      append_invalid() noexcept {
        append_begin();
        append_end();
        return content_;
      }
 
      BUILDER&
      extend_invalid(size_t size) noexcept {
        for (size_t i = 0; i < size; i++) {
          append_invalid();
        }
        return content_;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      void
      set_id(size_t& id) noexcept {
        id_ = id;
        id++;
        content_.set_id(id);
      }
 
      void
      clear() noexcept {
        mask_.clear();
        content_.clear();
        current_byte_ = 0;
        current_byte_ref_ = mask_.append_and_get_ref(current_byte_);
        current_index_ = 0;
      }
 
      size_t
      length() const noexcept {
        return mask_.length() > 0 ?
          (mask_.length() - 1) * 8 + current_index_ : current_index_;
      }
 
      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);
        }
      }
 
      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);
      }
 
      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);
      }
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
        if (std::string(name) == std::string("node" + std::to_string(id_) + "-mask")) {
          mask_.concatenate_from(reinterpret_cast<uint8_t*>(buffer), 0, 1);
          mask_.append(reinterpret_cast<uint8_t*>(buffer), mask_.length() - 1, 0, 1);
        }
        content_.to_buffer(buffer, name);
      }
 
      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);
      }
 
      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:
      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;
        }
      }
 
      void
      append_end() {
        current_index_ += 1;
        if (valid_when_) {
          current_byte_ref_ = current_byte_;
        } else {
          current_byte_ref_ = ~current_byte_;
        }
      }
 
      GrowableBuffer<uint8_t> mask_;
 
      BUILDER content_;
 
      std::string parameters_;
 
      size_t id_;
 
      uint8_t current_byte_;
 
      uint8_t& current_byte_ref_;
 
      size_t current_index_;
 
      uint8_t cast_[8];
 
      bool valid_when_ = VALID_WHEN;
 
      bool lsb_order_ = LSB_ORDER;
    };
 
    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>;
 
      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;
        }
      }
 
      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_);
      }
 
      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;
      }
 
      const std::string&
      parameters() const noexcept {
        return parameters_;
      }
 
      void
      set_parameters(std::string parameter) noexcept {
        parameters_ = parameter;
      }
 
      class SetIdFunctor {
      public:
          // Constructor to capture id by reference
          SetIdFunctor(size_t& id) : id_(id) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.set_id(id_);
          }
 
      private:
          size_t& id_;  // reference to the id
      };
 
      void
      set_id(size_t& id) noexcept {
          id_ = id;
          id++;
          SetIdFunctor setIdFunctor(id);  // instantiate the functor
          for (size_t i = 0; i < contents_count_; i++) {
              visit_at(contents_, i, setIdFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ClearContentsFunctor {
      public:
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.clear();
          }
      };
 
      void
      clear() noexcept {
          for (size_t i = 0; i < contents_count_; i++) {
              last_valid_index_[i] = -1;
          }
          tags_.clear();
          index_.clear();
 
          ClearContentsFunctor clearContentsFunctor;  // instantiate the functor
          for (size_t i = 0; i < contents_count_; i++) {
              visit_at(contents_, i, clearContentsFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      size_t
      length() const noexcept {
        return tags_.length();
      }
 
      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);
        std::unique_ptr<INDEX[]> index_ptr(new INDEX[index_.length()]);
        index_.concatenate(index_ptr.get());
        std::unique_ptr<TAGS[]> tags_ptr(new TAGS[tags_.length()]);
        tags_.concatenate(tags_ptr.get());
        for (size_t i = 0; i < index_.length(); i++) {
          if (index_ptr.get()[i] < 0 || index_ptr.get()[i] >= lengths[tags_ptr.get()[i]]) {
            std::stringstream out;
            out << "Union node" << id_ << " has index " << index_ptr.get()[i]
                << " at position " << i << " but content has length "
                << lengths[tags_ptr.get()[i]] << "\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>());
      }
 
      class BufferNBytesFunctor {
      public:
          // Constructor to capture names_nbytes by reference
          BufferNBytesFunctor(std::map<std::string, size_t>& names_nbytes)
              : names_nbytes_(names_nbytes) {}
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.buffer_nbytes(names_nbytes_);
          }
 
      private:
          std::map<std::string, size_t>& names_nbytes_;  // reference to the map
      };
 
      void
      buffer_nbytes(std::map<std::string, size_t>& names_nbytes) const noexcept {
          auto index_sequence((std::index_sequence_for<BUILDERS...>()));
 
          // Store the size of tags and index buffers
          names_nbytes["node" + std::to_string(id_) + "-tags"] = tags_.nbytes();
          names_nbytes["node" + std::to_string(id_) + "-index"] = index_.nbytes();
 
          // Instantiate the functor to handle each content's buffer_nbytes call
          BufferNBytesFunctor bufferNBytesFunctor(names_nbytes);
 
          for (size_t i = 0; i < contents_count_; i++) {
              visit_at(contents_, i, bufferNBytesFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ToBuffersFunctor {
      public:
          // Constructor to capture buffers by reference
          ToBuffersFunctor(std::map<std::string, void*>& buffers)
              : buffers_(buffers) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.to_buffers(buffers_);
          }
 
      private:
          std::map<std::string, void*>& buffers_;  // reference to the buffers map
      };
 
      void
      to_buffers(std::map<std::string, void*>& buffers) const noexcept {
          auto index_sequence((std::index_sequence_for<BUILDERS...>()));
 
          // Concatenate tags and index buffers
          tags_.concatenate(reinterpret_cast<TAGS*>(
              buffers["node" + std::to_string(id_) + "-tags"]));
          index_.concatenate(reinterpret_cast<INDEX*>(
              buffers["node" + std::to_string(id_) + "-index"]));
 
          // Create the functor to handle each content's to_buffers call
          ToBuffersFunctor toBuffersFunctor(buffers);
 
          for (size_t i = 0; i < contents_count_; i++) {
              visit_at(contents_, i, toBuffersFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ToBufferFunctor {
      public:
          // Constructor to capture buffer and name by reference
          ToBufferFunctor(void* buffer, const char* name)
              : buffer_(buffer), name_(name) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.to_buffer(buffer_, name_);
          }
 
      private:
          void* buffer_;            // reference to the buffer
          const char* name_;        // reference to the name
      };
 
      void
      to_buffer(void* buffer, const char* name) const noexcept {
          auto index_sequence((std::index_sequence_for<BUILDERS...>()));
 
          if (std::string(name) == std::string("node" + std::to_string(id_) + "-tags")) {
              tags_.concatenate(reinterpret_cast<TAGS*>(buffer));
          }
          else if (std::string(name) == std::string("node" + std::to_string(id_) + "-index")) {
              index_.concatenate(reinterpret_cast<INDEX*>(buffer));
          }
 
          // Instantiate the functor to handle each content's to_buffer call
          ToBufferFunctor toBufferFunctor(buffer, name);
 
          for (size_t i = 0; i < contents_count_; i++) {
              visit_at(contents_, i, toBufferFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ToCharBuffersFunctor {
      public:
          // Constructor to capture buffers by reference
          ToCharBuffersFunctor(std::map<std::string, uint8_t*>& buffers)
              : buffers_(buffers) { }
 
          // Template operator() to handle the content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              content.to_char_buffers(buffers_);
          }
 
      private:
          std::map<std::string, uint8_t*>& buffers_;  // reference to the buffers map
      };
 
      void
      to_char_buffers(std::map<std::string, uint8_t*>& buffers) const noexcept {
          auto index_sequence((std::index_sequence_for<BUILDERS...>()));
 
          // Concatenate tags and index buffers
          tags_.concatenate(reinterpret_cast<TAGS*>(
              buffers["node" + std::to_string(id_) + "-tags"]));
          index_.concatenate(reinterpret_cast<INDEX*>(
              buffers["node" + std::to_string(id_) + "-index"]));
 
          // Instantiate the functor to handle each content's to_char_buffers call
          ToCharBuffersFunctor toCharBuffersFunctor(buffers);
 
          for (size_t i = 0; i < contents_count_; i++) {
              visit_at(contents_, i, toCharBuffersFunctor);  // pass the functor instead of the lambda
          }
      }
 
 
      class ContentsFormFunctor {
      public:
          ContentsFormFunctor(std::stringstream& out)
              : out_(out) {}
 
          // Template operator() to handle each content
          template <class CONTENT>
          void operator()(CONTENT& content) const {
              out_ << content.form();
          }
 
      private:
          std::stringstream& out_;  // Reference to the output stringstream
      };
 
 
      std::string
      form() const noexcept {
          std::stringstream form_key;
          form_key << "node" << id_;
          std::string params("");
          if (!parameters_.empty()) {
              params = ", \"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 << ", ";
              }
              ContentsFormFunctor contentsFormFunctor(out);
              visit_at(contents_, i, contentsFormFunctor);
          }
          out << "], ";
          out << params << "\"form_key\": \"" << form_key.str() << "\" }";
          return out.str();
      }
 
 
    private:
      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()...});
      }
 
      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)...});
      }
 
      GrowableBuffer<TAGS> tags_;
 
      GrowableBuffer<INDEX> index_;
 
      Contents contents_;
 
      std::string parameters_;
 
      size_t id_;
 
      size_t last_valid_index_[sizeof...(BUILDERS)];
 
      static constexpr size_t contents_count_ = sizeof...(BUILDERS);
    };
 
  }  // namespace LayoutBuilder
}  // namespace awkward
 
#endif  // AWKWARD_LAYOUTBUILDER_H_