Restoring authorship annotation for <primorial@yandex-team.ru>. Commit 2 of 2.

1 files changed, 659 insertions, 659 deletions

diff --git a/contrib/libs/apache/arrow/cpp/src/generated/Message_generated.h b/contrib/libs/apache/arrow/cpp/src/generated/Message_generated.h
index aaac55801e..822bec9952 100644
--- a/contrib/libs/apache/arrow/cpp/src/generated/Message_generated.h
+++ b/contrib/libs/apache/arrow/cpp/src/generated/Message_generated.h
@@ -1,659 +1,659 @@
-// automatically generated by the FlatBuffers compiler, do not modify 
- 
- 
-#ifndef FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_ 
-#define FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_ 
- 
-#include "flatbuffers/flatbuffers.h" 
- 
-#include "Schema_generated.h" 
-#include "SparseTensor_generated.h" 
-#include "Tensor_generated.h" 
- 
-namespace org { 
-namespace apache { 
-namespace arrow { 
-namespace flatbuf { 
- 
-struct FieldNode; 
- 
-struct BodyCompression; 
-struct BodyCompressionBuilder; 
- 
-struct RecordBatch; 
-struct RecordBatchBuilder; 
- 
-struct DictionaryBatch; 
-struct DictionaryBatchBuilder; 
- 
-struct Message; 
-struct MessageBuilder; 
- 
-enum class CompressionType : int8_t { 
-  LZ4_FRAME = 0, 
-  ZSTD = 1, 
-  MIN = LZ4_FRAME, 
-  MAX = ZSTD 
-}; 
- 
-inline const CompressionType (&EnumValuesCompressionType())[2] { 
-  static const CompressionType values[] = { 
-    CompressionType::LZ4_FRAME, 
-    CompressionType::ZSTD 
-  }; 
-  return values; 
-} 
- 
-inline const char * const *EnumNamesCompressionType() { 
-  static const char * const names[3] = { 
-    "LZ4_FRAME", 
-    "ZSTD", 
-    nullptr 
-  }; 
-  return names; 
-} 
- 
-inline const char *EnumNameCompressionType(CompressionType e) { 
-  if (flatbuffers::IsOutRange(e, CompressionType::LZ4_FRAME, CompressionType::ZSTD)) return ""; 
-  const size_t index = static_cast<size_t>(e); 
-  return EnumNamesCompressionType()[index]; 
-} 
- 
-/// Provided for forward compatibility in case we need to support different 
-/// strategies for compressing the IPC message body (like whole-body 
-/// compression rather than buffer-level) in the future 
-enum class BodyCompressionMethod : int8_t { 
-  /// Each constituent buffer is first compressed with the indicated 
-  /// compressor, and then written with the uncompressed length in the first 8 
-  /// bytes as a 64-bit little-endian signed integer followed by the compressed 
-  /// buffer bytes (and then padding as required by the protocol). The 
-  /// uncompressed length may be set to -1 to indicate that the data that 
-  /// follows is not compressed, which can be useful for cases where 
-  /// compression does not yield appreciable savings. 
-  BUFFER = 0, 
-  MIN = BUFFER, 
-  MAX = BUFFER 
-}; 
- 
-inline const BodyCompressionMethod (&EnumValuesBodyCompressionMethod())[1] { 
-  static const BodyCompressionMethod values[] = { 
-    BodyCompressionMethod::BUFFER 
-  }; 
-  return values; 
-} 
- 
-inline const char * const *EnumNamesBodyCompressionMethod() { 
-  static const char * const names[2] = { 
-    "BUFFER", 
-    nullptr 
-  }; 
-  return names; 
-} 
- 
-inline const char *EnumNameBodyCompressionMethod(BodyCompressionMethod e) { 
-  if (flatbuffers::IsOutRange(e, BodyCompressionMethod::BUFFER, BodyCompressionMethod::BUFFER)) return ""; 
-  const size_t index = static_cast<size_t>(e); 
-  return EnumNamesBodyCompressionMethod()[index]; 
-} 
- 
-/// ---------------------------------------------------------------------- 
-/// The root Message type 
-/// This union enables us to easily send different message types without 
-/// redundant storage, and in the future we can easily add new message types. 
-/// 
-/// Arrow implementations do not need to implement all of the message types, 
-/// which may include experimental metadata types. For maximum compatibility, 
-/// it is best to send data using RecordBatch 
-enum class MessageHeader : uint8_t { 
-  NONE = 0, 
-  Schema = 1, 
-  DictionaryBatch = 2, 
-  RecordBatch = 3, 
-  Tensor = 4, 
-  SparseTensor = 5, 
-  MIN = NONE, 
-  MAX = SparseTensor 
-}; 
- 
-inline const MessageHeader (&EnumValuesMessageHeader())[6] { 
-  static const MessageHeader values[] = { 
-    MessageHeader::NONE, 
-    MessageHeader::Schema, 
-    MessageHeader::DictionaryBatch, 
-    MessageHeader::RecordBatch, 
-    MessageHeader::Tensor, 
-    MessageHeader::SparseTensor 
-  }; 
-  return values; 
-} 
- 
-inline const char * const *EnumNamesMessageHeader() { 
-  static const char * const names[7] = { 
-    "NONE", 
-    "Schema", 
-    "DictionaryBatch", 
-    "RecordBatch", 
-    "Tensor", 
-    "SparseTensor", 
-    nullptr 
-  }; 
-  return names; 
-} 
- 
-inline const char *EnumNameMessageHeader(MessageHeader e) { 
-  if (flatbuffers::IsOutRange(e, MessageHeader::NONE, MessageHeader::SparseTensor)) return ""; 
-  const size_t index = static_cast<size_t>(e); 
-  return EnumNamesMessageHeader()[index]; 
-} 
- 
-template<typename T> struct MessageHeaderTraits { 
-  static const MessageHeader enum_value = MessageHeader::NONE; 
-}; 
- 
-template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::Schema> { 
-  static const MessageHeader enum_value = MessageHeader::Schema; 
-}; 
- 
-template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::DictionaryBatch> { 
-  static const MessageHeader enum_value = MessageHeader::DictionaryBatch; 
-}; 
- 
-template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::RecordBatch> { 
-  static const MessageHeader enum_value = MessageHeader::RecordBatch; 
-}; 
- 
-template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::Tensor> { 
-  static const MessageHeader enum_value = MessageHeader::Tensor; 
-}; 
- 
-template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::SparseTensor> { 
-  static const MessageHeader enum_value = MessageHeader::SparseTensor; 
-}; 
- 
-bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type); 
-bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 
- 
-/// ---------------------------------------------------------------------- 
-/// Data structures for describing a table row batch (a collection of 
-/// equal-length Arrow arrays) 
-/// Metadata about a field at some level of a nested type tree (but not 
-/// its children). 
-/// 
-/// For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null] 
-/// would have {length: 5, null_count: 2} for its List node, and {length: 6, 
-/// null_count: 0} for its Int16 node, as separate FieldNode structs 
-FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS { 
- private: 
-  int64_t length_; 
-  int64_t null_count_; 
- 
- public: 
-  FieldNode() { 
-    memset(static_cast<void *>(this), 0, sizeof(FieldNode)); 
-  } 
-  FieldNode(int64_t _length, int64_t _null_count) 
-      : length_(flatbuffers::EndianScalar(_length)), 
-        null_count_(flatbuffers::EndianScalar(_null_count)) { 
-  } 
-  /// The number of value slots in the Arrow array at this level of a nested 
-  /// tree 
-  int64_t length() const { 
-    return flatbuffers::EndianScalar(length_); 
-  } 
-  /// The number of observed nulls. Fields with null_count == 0 may choose not 
-  /// to write their physical validity bitmap out as a materialized buffer, 
-  /// instead setting the length of the bitmap buffer to 0. 
-  int64_t null_count() const { 
-    return flatbuffers::EndianScalar(null_count_); 
-  } 
-}; 
-FLATBUFFERS_STRUCT_END(FieldNode, 16); 
- 
-/// Optional compression for the memory buffers constituting IPC message 
-/// bodies. Intended for use with RecordBatch but could be used for other 
-/// message types 
-struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 
-  typedef BodyCompressionBuilder Builder; 
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 
-    VT_CODEC = 4, 
-    VT_METHOD = 6 
-  }; 
-  /// Compressor library 
-  org::apache::arrow::flatbuf::CompressionType codec() const { 
-    return static_cast<org::apache::arrow::flatbuf::CompressionType>(GetField<int8_t>(VT_CODEC, 0)); 
-  } 
-  /// Indicates the way the record batch body was compressed 
-  org::apache::arrow::flatbuf::BodyCompressionMethod method() const { 
-    return static_cast<org::apache::arrow::flatbuf::BodyCompressionMethod>(GetField<int8_t>(VT_METHOD, 0)); 
-  } 
-  bool Verify(flatbuffers::Verifier &verifier) const { 
-    return VerifyTableStart(verifier) && 
-           VerifyField<int8_t>(verifier, VT_CODEC) && 
-           VerifyField<int8_t>(verifier, VT_METHOD) && 
-           verifier.EndTable(); 
-  } 
-}; 
- 
-struct BodyCompressionBuilder { 
-  typedef BodyCompression Table; 
-  flatbuffers::FlatBufferBuilder &fbb_; 
-  flatbuffers::uoffset_t start_; 
-  void add_codec(org::apache::arrow::flatbuf::CompressionType codec) { 
-    fbb_.AddElement<int8_t>(BodyCompression::VT_CODEC, static_cast<int8_t>(codec), 0); 
-  } 
-  void add_method(org::apache::arrow::flatbuf::BodyCompressionMethod method) { 
-    fbb_.AddElement<int8_t>(BodyCompression::VT_METHOD, static_cast<int8_t>(method), 0); 
-  } 
-  explicit BodyCompressionBuilder(flatbuffers::FlatBufferBuilder &_fbb) 
-        : fbb_(_fbb) { 
-    start_ = fbb_.StartTable(); 
-  } 
-  BodyCompressionBuilder &operator=(const BodyCompressionBuilder &); 
-  flatbuffers::Offset<BodyCompression> Finish() { 
-    const auto end = fbb_.EndTable(start_); 
-    auto o = flatbuffers::Offset<BodyCompression>(end); 
-    return o; 
-  } 
-}; 
- 
-inline flatbuffers::Offset<BodyCompression> CreateBodyCompression( 
-    flatbuffers::FlatBufferBuilder &_fbb, 
-    org::apache::arrow::flatbuf::CompressionType codec = org::apache::arrow::flatbuf::CompressionType::LZ4_FRAME, 
-    org::apache::arrow::flatbuf::BodyCompressionMethod method = org::apache::arrow::flatbuf::BodyCompressionMethod::BUFFER) { 
-  BodyCompressionBuilder builder_(_fbb); 
-  builder_.add_method(method); 
-  builder_.add_codec(codec); 
-  return builder_.Finish(); 
-} 
- 
-/// A data header describing the shared memory layout of a "record" or "row" 
-/// batch. Some systems call this a "row batch" internally and others a "record 
-/// batch". 
-struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 
-  typedef RecordBatchBuilder Builder; 
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 
-    VT_LENGTH = 4, 
-    VT_NODES = 6, 
-    VT_BUFFERS = 8, 
-    VT_COMPRESSION = 10 
-  }; 
-  /// number of records / rows. The arrays in the batch should all have this 
-  /// length 
-  int64_t length() const { 
-    return GetField<int64_t>(VT_LENGTH, 0); 
-  } 
-  /// Nodes correspond to the pre-ordered flattened logical schema 
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *nodes() const { 
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *>(VT_NODES); 
-  } 
-  /// Buffers correspond to the pre-ordered flattened buffer tree 
-  /// 
-  /// The number of buffers appended to this list depends on the schema. For 
-  /// example, most primitive arrays will have 2 buffers, 1 for the validity 
-  /// bitmap and 1 for the values. For struct arrays, there will only be a 
-  /// single buffer for the validity (nulls) bitmap 
-  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *buffers() const { 
-    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_BUFFERS); 
-  } 
-  /// Optional compression of the message body 
-  const org::apache::arrow::flatbuf::BodyCompression *compression() const { 
-    return GetPointer<const org::apache::arrow::flatbuf::BodyCompression *>(VT_COMPRESSION); 
-  } 
-  bool Verify(flatbuffers::Verifier &verifier) const { 
-    return VerifyTableStart(verifier) && 
-           VerifyField<int64_t>(verifier, VT_LENGTH) && 
-           VerifyOffset(verifier, VT_NODES) && 
-           verifier.VerifyVector(nodes()) && 
-           VerifyOffset(verifier, VT_BUFFERS) && 
-           verifier.VerifyVector(buffers()) && 
-           VerifyOffset(verifier, VT_COMPRESSION) && 
-           verifier.VerifyTable(compression()) && 
-           verifier.EndTable(); 
-  } 
-}; 
- 
-struct RecordBatchBuilder { 
-  typedef RecordBatch Table; 
-  flatbuffers::FlatBufferBuilder &fbb_; 
-  flatbuffers::uoffset_t start_; 
-  void add_length(int64_t length) { 
-    fbb_.AddElement<int64_t>(RecordBatch::VT_LENGTH, length, 0); 
-  } 
-  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes) { 
-    fbb_.AddOffset(RecordBatch::VT_NODES, nodes); 
-  } 
-  void add_buffers(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers) { 
-    fbb_.AddOffset(RecordBatch::VT_BUFFERS, buffers); 
-  } 
-  void add_compression(flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression) { 
-    fbb_.AddOffset(RecordBatch::VT_COMPRESSION, compression); 
-  } 
-  explicit RecordBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb) 
-        : fbb_(_fbb) { 
-    start_ = fbb_.StartTable(); 
-  } 
-  RecordBatchBuilder &operator=(const RecordBatchBuilder &); 
-  flatbuffers::Offset<RecordBatch> Finish() { 
-    const auto end = fbb_.EndTable(start_); 
-    auto o = flatbuffers::Offset<RecordBatch>(end); 
-    return o; 
-  } 
-}; 
- 
-inline flatbuffers::Offset<RecordBatch> CreateRecordBatch( 
-    flatbuffers::FlatBufferBuilder &_fbb, 
-    int64_t length = 0, 
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes = 0, 
-    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers = 0, 
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) { 
-  RecordBatchBuilder builder_(_fbb); 
-  builder_.add_length(length); 
-  builder_.add_compression(compression); 
-  builder_.add_buffers(buffers); 
-  builder_.add_nodes(nodes); 
-  return builder_.Finish(); 
-} 
- 
-inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect( 
-    flatbuffers::FlatBufferBuilder &_fbb, 
-    int64_t length = 0, 
-    const std::vector<org::apache::arrow::flatbuf::FieldNode> *nodes = nullptr, 
-    const std::vector<org::apache::arrow::flatbuf::Buffer> *buffers = nullptr, 
-    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) { 
-  auto nodes__ = nodes ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::FieldNode>(*nodes) : 0; 
-  auto buffers__ = buffers ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Buffer>(*buffers) : 0; 
-  return org::apache::arrow::flatbuf::CreateRecordBatch( 
-      _fbb, 
-      length, 
-      nodes__, 
-      buffers__, 
-      compression); 
-} 
- 
-/// For sending dictionary encoding information. Any Field can be 
-/// dictionary-encoded, but in this case none of its children may be 
-/// dictionary-encoded. 
-/// There is one vector / column per dictionary, but that vector / column 
-/// may be spread across multiple dictionary batches by using the isDelta 
-/// flag 
-struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 
-  typedef DictionaryBatchBuilder Builder; 
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 
-    VT_ID = 4, 
-    VT_DATA = 6, 
-    VT_ISDELTA = 8 
-  }; 
-  int64_t id() const { 
-    return GetField<int64_t>(VT_ID, 0); 
-  } 
-  const org::apache::arrow::flatbuf::RecordBatch *data() const { 
-    return GetPointer<const org::apache::arrow::flatbuf::RecordBatch *>(VT_DATA); 
-  } 
-  /// If isDelta is true the values in the dictionary are to be appended to a 
-  /// dictionary with the indicated id. If isDelta is false this dictionary 
-  /// should replace the existing dictionary. 
-  bool isDelta() const { 
-    return GetField<uint8_t>(VT_ISDELTA, 0) != 0; 
-  } 
-  bool Verify(flatbuffers::Verifier &verifier) const { 
-    return VerifyTableStart(verifier) && 
-           VerifyField<int64_t>(verifier, VT_ID) && 
-           VerifyOffset(verifier, VT_DATA) && 
-           verifier.VerifyTable(data()) && 
-           VerifyField<uint8_t>(verifier, VT_ISDELTA) && 
-           verifier.EndTable(); 
-  } 
-}; 
- 
-struct DictionaryBatchBuilder { 
-  typedef DictionaryBatch Table; 
-  flatbuffers::FlatBufferBuilder &fbb_; 
-  flatbuffers::uoffset_t start_; 
-  void add_id(int64_t id) { 
-    fbb_.AddElement<int64_t>(DictionaryBatch::VT_ID, id, 0); 
-  } 
-  void add_data(flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data) { 
-    fbb_.AddOffset(DictionaryBatch::VT_DATA, data); 
-  } 
-  void add_isDelta(bool isDelta) { 
-    fbb_.AddElement<uint8_t>(DictionaryBatch::VT_ISDELTA, static_cast<uint8_t>(isDelta), 0); 
-  } 
-  explicit DictionaryBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb) 
-        : fbb_(_fbb) { 
-    start_ = fbb_.StartTable(); 
-  } 
-  DictionaryBatchBuilder &operator=(const DictionaryBatchBuilder &); 
-  flatbuffers::Offset<DictionaryBatch> Finish() { 
-    const auto end = fbb_.EndTable(start_); 
-    auto o = flatbuffers::Offset<DictionaryBatch>(end); 
-    return o; 
-  } 
-}; 
- 
-inline flatbuffers::Offset<DictionaryBatch> CreateDictionaryBatch( 
-    flatbuffers::FlatBufferBuilder &_fbb, 
-    int64_t id = 0, 
-    flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data = 0, 
-    bool isDelta = false) { 
-  DictionaryBatchBuilder builder_(_fbb); 
-  builder_.add_id(id); 
-  builder_.add_data(data); 
-  builder_.add_isDelta(isDelta); 
-  return builder_.Finish(); 
-} 
- 
-struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 
-  typedef MessageBuilder Builder; 
-  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 
-    VT_VERSION = 4, 
-    VT_HEADER_TYPE = 6, 
-    VT_HEADER = 8, 
-    VT_BODYLENGTH = 10, 
-    VT_CUSTOM_METADATA = 12 
-  }; 
-  org::apache::arrow::flatbuf::MetadataVersion version() const { 
-    return static_cast<org::apache::arrow::flatbuf::MetadataVersion>(GetField<int16_t>(VT_VERSION, 0)); 
-  } 
-  org::apache::arrow::flatbuf::MessageHeader header_type() const { 
-    return static_cast<org::apache::arrow::flatbuf::MessageHeader>(GetField<uint8_t>(VT_HEADER_TYPE, 0)); 
-  } 
-  const void *header() const { 
-    return GetPointer<const void *>(VT_HEADER); 
-  } 
-  template<typename T> const T *header_as() const; 
-  const org::apache::arrow::flatbuf::Schema *header_as_Schema() const { 
-    return header_type() == org::apache::arrow::flatbuf::MessageHeader::Schema ? static_cast<const org::apache::arrow::flatbuf::Schema *>(header()) : nullptr; 
-  } 
-  const org::apache::arrow::flatbuf::DictionaryBatch *header_as_DictionaryBatch() const { 
-    return header_type() == org::apache::arrow::flatbuf::MessageHeader::DictionaryBatch ? static_cast<const org::apache::arrow::flatbuf::DictionaryBatch *>(header()) : nullptr; 
-  } 
-  const org::apache::arrow::flatbuf::RecordBatch *header_as_RecordBatch() const { 
-    return header_type() == org::apache::arrow::flatbuf::MessageHeader::RecordBatch ? static_cast<const org::apache::arrow::flatbuf::RecordBatch *>(header()) : nullptr; 
-  } 
-  const org::apache::arrow::flatbuf::Tensor *header_as_Tensor() const { 
-    return header_type() == org::apache::arrow::flatbuf::MessageHeader::Tensor ? static_cast<const org::apache::arrow::flatbuf::Tensor *>(header()) : nullptr; 
-  } 
-  const org::apache::arrow::flatbuf::SparseTensor *header_as_SparseTensor() const { 
-    return header_type() == org::apache::arrow::flatbuf::MessageHeader::SparseTensor ? static_cast<const org::apache::arrow::flatbuf::SparseTensor *>(header()) : nullptr; 
-  } 
-  int64_t bodyLength() const { 
-    return GetField<int64_t>(VT_BODYLENGTH, 0); 
-  } 
-  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const { 
-    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA); 
-  } 
-  bool Verify(flatbuffers::Verifier &verifier) const { 
-    return VerifyTableStart(verifier) && 
-           VerifyField<int16_t>(verifier, VT_VERSION) && 
-           VerifyField<uint8_t>(verifier, VT_HEADER_TYPE) && 
-           VerifyOffset(verifier, VT_HEADER) && 
-           VerifyMessageHeader(verifier, header(), header_type()) && 
-           VerifyField<int64_t>(verifier, VT_BODYLENGTH) && 
-           VerifyOffset(verifier, VT_CUSTOM_METADATA) && 
-           verifier.VerifyVector(custom_metadata()) && 
-           verifier.VerifyVectorOfTables(custom_metadata()) && 
-           verifier.EndTable(); 
-  } 
-}; 
- 
-template<> inline const org::apache::arrow::flatbuf::Schema *Message::header_as<org::apache::arrow::flatbuf::Schema>() const { 
-  return header_as_Schema(); 
-} 
- 
-template<> inline const org::apache::arrow::flatbuf::DictionaryBatch *Message::header_as<org::apache::arrow::flatbuf::DictionaryBatch>() const { 
-  return header_as_DictionaryBatch(); 
-} 
- 
-template<> inline const org::apache::arrow::flatbuf::RecordBatch *Message::header_as<org::apache::arrow::flatbuf::RecordBatch>() const { 
-  return header_as_RecordBatch(); 
-} 
- 
-template<> inline const org::apache::arrow::flatbuf::Tensor *Message::header_as<org::apache::arrow::flatbuf::Tensor>() const { 
-  return header_as_Tensor(); 
-} 
- 
-template<> inline const org::apache::arrow::flatbuf::SparseTensor *Message::header_as<org::apache::arrow::flatbuf::SparseTensor>() const { 
-  return header_as_SparseTensor(); 
-} 
- 
-struct MessageBuilder { 
-  typedef Message Table; 
-  flatbuffers::FlatBufferBuilder &fbb_; 
-  flatbuffers::uoffset_t start_; 
-  void add_version(org::apache::arrow::flatbuf::MetadataVersion version) { 
-    fbb_.AddElement<int16_t>(Message::VT_VERSION, static_cast<int16_t>(version), 0); 
-  } 
-  void add_header_type(org::apache::arrow::flatbuf::MessageHeader header_type) { 
-    fbb_.AddElement<uint8_t>(Message::VT_HEADER_TYPE, static_cast<uint8_t>(header_type), 0); 
-  } 
-  void add_header(flatbuffers::Offset<void> header) { 
-    fbb_.AddOffset(Message::VT_HEADER, header); 
-  } 
-  void add_bodyLength(int64_t bodyLength) { 
-    fbb_.AddElement<int64_t>(Message::VT_BODYLENGTH, bodyLength, 0); 
-  } 
-  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) { 
-    fbb_.AddOffset(Message::VT_CUSTOM_METADATA, custom_metadata); 
-  } 
-  explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) 
-        : fbb_(_fbb) { 
-    start_ = fbb_.StartTable(); 
-  } 
-  MessageBuilder &operator=(const MessageBuilder &); 
-  flatbuffers::Offset<Message> Finish() { 
-    const auto end = fbb_.EndTable(start_); 
-    auto o = flatbuffers::Offset<Message>(end); 
-    return o; 
-  } 
-}; 
- 
-inline flatbuffers::Offset<Message> CreateMessage( 
-    flatbuffers::FlatBufferBuilder &_fbb, 
-    org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1, 
-    org::apache::arrow::flatbuf::MessageHeader header_type = org::apache::arrow::flatbuf::MessageHeader::NONE, 
-    flatbuffers::Offset<void> header = 0, 
-    int64_t bodyLength = 0, 
-    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) { 
-  MessageBuilder builder_(_fbb); 
-  builder_.add_bodyLength(bodyLength); 
-  builder_.add_custom_metadata(custom_metadata); 
-  builder_.add_header(header); 
-  builder_.add_version(version); 
-  builder_.add_header_type(header_type); 
-  return builder_.Finish(); 
-} 
- 
-inline flatbuffers::Offset<Message> CreateMessageDirect( 
-    flatbuffers::FlatBufferBuilder &_fbb, 
-    org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1, 
-    org::apache::arrow::flatbuf::MessageHeader header_type = org::apache::arrow::flatbuf::MessageHeader::NONE, 
-    flatbuffers::Offset<void> header = 0, 
-    int64_t bodyLength = 0, 
-    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) { 
-  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0; 
-  return org::apache::arrow::flatbuf::CreateMessage( 
-      _fbb, 
-      version, 
-      header_type, 
-      header, 
-      bodyLength, 
-      custom_metadata__); 
-} 
- 
-inline bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type) { 
-  switch (type) { 
-    case MessageHeader::NONE: { 
-      return true; 
-    } 
-    case MessageHeader::Schema: { 
-      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Schema *>(obj); 
-      return verifier.VerifyTable(ptr); 
-    } 
-    case MessageHeader::DictionaryBatch: { 
-      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::DictionaryBatch *>(obj); 
-      return verifier.VerifyTable(ptr); 
-    } 
-    case MessageHeader::RecordBatch: { 
-      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::RecordBatch *>(obj); 
-      return verifier.VerifyTable(ptr); 
-    } 
-    case MessageHeader::Tensor: { 
-      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Tensor *>(obj); 
-      return verifier.VerifyTable(ptr); 
-    } 
-    case MessageHeader::SparseTensor: { 
-      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::SparseTensor *>(obj); 
-      return verifier.VerifyTable(ptr); 
-    } 
-    default: return true; 
-  } 
-} 
- 
-inline bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 
-  if (!values || !types) return !values && !types; 
-  if (values->size() != types->size()) return false; 
-  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 
-    if (!VerifyMessageHeader( 
-        verifier,  values->Get(i), types->GetEnum<MessageHeader>(i))) { 
-      return false; 
-    } 
-  } 
-  return true; 
-} 
- 
-inline const org::apache::arrow::flatbuf::Message *GetMessage(const void *buf) { 
-  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Message>(buf); 
-} 
- 
-inline const org::apache::arrow::flatbuf::Message *GetSizePrefixedMessage(const void *buf) { 
-  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Message>(buf); 
-} 
- 
-inline bool VerifyMessageBuffer( 
-    flatbuffers::Verifier &verifier) { 
-  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Message>(nullptr); 
-} 
- 
-inline bool VerifySizePrefixedMessageBuffer( 
-    flatbuffers::Verifier &verifier) { 
-  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Message>(nullptr); 
-} 
- 
-inline void FinishMessageBuffer( 
-    flatbuffers::FlatBufferBuilder &fbb, 
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) { 
-  fbb.Finish(root); 
-} 
- 
-inline void FinishSizePrefixedMessageBuffer( 
-    flatbuffers::FlatBufferBuilder &fbb, 
-    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) { 
-  fbb.FinishSizePrefixed(root); 
-} 
- 
-}  // namespace flatbuf 
-}  // namespace arrow 
-}  // namespace apache 
-}  // namespace org 
- 
-#endif  // FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_ 
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "Schema_generated.h"
+#include "SparseTensor_generated.h"
+#include "Tensor_generated.h"
+
+namespace org {
+namespace apache {
+namespace arrow {
+namespace flatbuf {
+
+struct FieldNode;
+
+struct BodyCompression;
+struct BodyCompressionBuilder;
+
+struct RecordBatch;
+struct RecordBatchBuilder;
+
+struct DictionaryBatch;
+struct DictionaryBatchBuilder;
+
+struct Message;
+struct MessageBuilder;
+
+enum class CompressionType : int8_t {
+  LZ4_FRAME = 0,
+  ZSTD = 1,
+  MIN = LZ4_FRAME,
+  MAX = ZSTD
+};
+
+inline const CompressionType (&EnumValuesCompressionType())[2] {
+  static const CompressionType values[] = {
+    CompressionType::LZ4_FRAME,
+    CompressionType::ZSTD
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesCompressionType() {
+  static const char * const names[3] = {
+    "LZ4_FRAME",
+    "ZSTD",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameCompressionType(CompressionType e) {
+  if (flatbuffers::IsOutRange(e, CompressionType::LZ4_FRAME, CompressionType::ZSTD)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesCompressionType()[index];
+}
+
+/// Provided for forward compatibility in case we need to support different
+/// strategies for compressing the IPC message body (like whole-body
+/// compression rather than buffer-level) in the future
+enum class BodyCompressionMethod : int8_t {
+  /// Each constituent buffer is first compressed with the indicated
+  /// compressor, and then written with the uncompressed length in the first 8
+  /// bytes as a 64-bit little-endian signed integer followed by the compressed
+  /// buffer bytes (and then padding as required by the protocol). The
+  /// uncompressed length may be set to -1 to indicate that the data that
+  /// follows is not compressed, which can be useful for cases where
+  /// compression does not yield appreciable savings.
+  BUFFER = 0,
+  MIN = BUFFER,
+  MAX = BUFFER
+};
+
+inline const BodyCompressionMethod (&EnumValuesBodyCompressionMethod())[1] {
+  static const BodyCompressionMethod values[] = {
+    BodyCompressionMethod::BUFFER
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesBodyCompressionMethod() {
+  static const char * const names[2] = {
+    "BUFFER",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameBodyCompressionMethod(BodyCompressionMethod e) {
+  if (flatbuffers::IsOutRange(e, BodyCompressionMethod::BUFFER, BodyCompressionMethod::BUFFER)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesBodyCompressionMethod()[index];
+}
+
+/// ----------------------------------------------------------------------
+/// The root Message type
+/// This union enables us to easily send different message types without
+/// redundant storage, and in the future we can easily add new message types.
+///
+/// Arrow implementations do not need to implement all of the message types,
+/// which may include experimental metadata types. For maximum compatibility,
+/// it is best to send data using RecordBatch
+enum class MessageHeader : uint8_t {
+  NONE = 0,
+  Schema = 1,
+  DictionaryBatch = 2,
+  RecordBatch = 3,
+  Tensor = 4,
+  SparseTensor = 5,
+  MIN = NONE,
+  MAX = SparseTensor
+};
+
+inline const MessageHeader (&EnumValuesMessageHeader())[6] {
+  static const MessageHeader values[] = {
+    MessageHeader::NONE,
+    MessageHeader::Schema,
+    MessageHeader::DictionaryBatch,
+    MessageHeader::RecordBatch,
+    MessageHeader::Tensor,
+    MessageHeader::SparseTensor
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMessageHeader() {
+  static const char * const names[7] = {
+    "NONE",
+    "Schema",
+    "DictionaryBatch",
+    "RecordBatch",
+    "Tensor",
+    "SparseTensor",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameMessageHeader(MessageHeader e) {
+  if (flatbuffers::IsOutRange(e, MessageHeader::NONE, MessageHeader::SparseTensor)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesMessageHeader()[index];
+}
+
+template<typename T> struct MessageHeaderTraits {
+  static const MessageHeader enum_value = MessageHeader::NONE;
+};
+
+template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::Schema> {
+  static const MessageHeader enum_value = MessageHeader::Schema;
+};
+
+template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::DictionaryBatch> {
+  static const MessageHeader enum_value = MessageHeader::DictionaryBatch;
+};
+
+template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::RecordBatch> {
+  static const MessageHeader enum_value = MessageHeader::RecordBatch;
+};
+
+template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::Tensor> {
+  static const MessageHeader enum_value = MessageHeader::Tensor;
+};
+
+template<> struct MessageHeaderTraits<org::apache::arrow::flatbuf::SparseTensor> {
+  static const MessageHeader enum_value = MessageHeader::SparseTensor;
+};
+
+bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type);
+bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+/// ----------------------------------------------------------------------
+/// Data structures for describing a table row batch (a collection of
+/// equal-length Arrow arrays)
+/// Metadata about a field at some level of a nested type tree (but not
+/// its children).
+///
+/// For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null]
+/// would have {length: 5, null_count: 2} for its List node, and {length: 6,
+/// null_count: 0} for its Int16 node, as separate FieldNode structs
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
+ private:
+  int64_t length_;
+  int64_t null_count_;
+
+ public:
+  FieldNode() {
+    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
+  }
+  FieldNode(int64_t _length, int64_t _null_count)
+      : length_(flatbuffers::EndianScalar(_length)),
+        null_count_(flatbuffers::EndianScalar(_null_count)) {
+  }
+  /// The number of value slots in the Arrow array at this level of a nested
+  /// tree
+  int64_t length() const {
+    return flatbuffers::EndianScalar(length_);
+  }
+  /// The number of observed nulls. Fields with null_count == 0 may choose not
+  /// to write their physical validity bitmap out as a materialized buffer,
+  /// instead setting the length of the bitmap buffer to 0.
+  int64_t null_count() const {
+    return flatbuffers::EndianScalar(null_count_);
+  }
+};
+FLATBUFFERS_STRUCT_END(FieldNode, 16);
+
+/// Optional compression for the memory buffers constituting IPC message
+/// bodies. Intended for use with RecordBatch but could be used for other
+/// message types
+struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef BodyCompressionBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_CODEC = 4,
+    VT_METHOD = 6
+  };
+  /// Compressor library
+  org::apache::arrow::flatbuf::CompressionType codec() const {
+    return static_cast<org::apache::arrow::flatbuf::CompressionType>(GetField<int8_t>(VT_CODEC, 0));
+  }
+  /// Indicates the way the record batch body was compressed
+  org::apache::arrow::flatbuf::BodyCompressionMethod method() const {
+    return static_cast<org::apache::arrow::flatbuf::BodyCompressionMethod>(GetField<int8_t>(VT_METHOD, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int8_t>(verifier, VT_CODEC) &&
+           VerifyField<int8_t>(verifier, VT_METHOD) &&
+           verifier.EndTable();
+  }
+};
+
+struct BodyCompressionBuilder {
+  typedef BodyCompression Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_codec(org::apache::arrow::flatbuf::CompressionType codec) {
+    fbb_.AddElement<int8_t>(BodyCompression::VT_CODEC, static_cast<int8_t>(codec), 0);
+  }
+  void add_method(org::apache::arrow::flatbuf::BodyCompressionMethod method) {
+    fbb_.AddElement<int8_t>(BodyCompression::VT_METHOD, static_cast<int8_t>(method), 0);
+  }
+  explicit BodyCompressionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  BodyCompressionBuilder &operator=(const BodyCompressionBuilder &);
+  flatbuffers::Offset<BodyCompression> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<BodyCompression>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<BodyCompression> CreateBodyCompression(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    org::apache::arrow::flatbuf::CompressionType codec = org::apache::arrow::flatbuf::CompressionType::LZ4_FRAME,
+    org::apache::arrow::flatbuf::BodyCompressionMethod method = org::apache::arrow::flatbuf::BodyCompressionMethod::BUFFER) {
+  BodyCompressionBuilder builder_(_fbb);
+  builder_.add_method(method);
+  builder_.add_codec(codec);
+  return builder_.Finish();
+}
+
+/// A data header describing the shared memory layout of a "record" or "row"
+/// batch. Some systems call this a "row batch" internally and others a "record
+/// batch".
+struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef RecordBatchBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LENGTH = 4,
+    VT_NODES = 6,
+    VT_BUFFERS = 8,
+    VT_COMPRESSION = 10
+  };
+  /// number of records / rows. The arrays in the batch should all have this
+  /// length
+  int64_t length() const {
+    return GetField<int64_t>(VT_LENGTH, 0);
+  }
+  /// Nodes correspond to the pre-ordered flattened logical schema
+  const flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *nodes() const {
+    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *> *>(VT_NODES);
+  }
+  /// Buffers correspond to the pre-ordered flattened buffer tree
+  ///
+  /// The number of buffers appended to this list depends on the schema. For
+  /// example, most primitive arrays will have 2 buffers, 1 for the validity
+  /// bitmap and 1 for the values. For struct arrays, there will only be a
+  /// single buffer for the validity (nulls) bitmap
+  const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *buffers() const {
+    return GetPointer<const flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *> *>(VT_BUFFERS);
+  }
+  /// Optional compression of the message body
+  const org::apache::arrow::flatbuf::BodyCompression *compression() const {
+    return GetPointer<const org::apache::arrow::flatbuf::BodyCompression *>(VT_COMPRESSION);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_LENGTH) &&
+           VerifyOffset(verifier, VT_NODES) &&
+           verifier.VerifyVector(nodes()) &&
+           VerifyOffset(verifier, VT_BUFFERS) &&
+           verifier.VerifyVector(buffers()) &&
+           VerifyOffset(verifier, VT_COMPRESSION) &&
+           verifier.VerifyTable(compression()) &&
+           verifier.EndTable();
+  }
+};
+
+struct RecordBatchBuilder {
+  typedef RecordBatch Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_length(int64_t length) {
+    fbb_.AddElement<int64_t>(RecordBatch::VT_LENGTH, length, 0);
+  }
+  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes) {
+    fbb_.AddOffset(RecordBatch::VT_NODES, nodes);
+  }
+  void add_buffers(flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers) {
+    fbb_.AddOffset(RecordBatch::VT_BUFFERS, buffers);
+  }
+  void add_compression(flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression) {
+    fbb_.AddOffset(RecordBatch::VT_COMPRESSION, compression);
+  }
+  explicit RecordBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  RecordBatchBuilder &operator=(const RecordBatchBuilder &);
+  flatbuffers::Offset<RecordBatch> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<RecordBatch>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<RecordBatch> CreateRecordBatch(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t length = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::FieldNode *>> nodes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const org::apache::arrow::flatbuf::Buffer *>> buffers = 0,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) {
+  RecordBatchBuilder builder_(_fbb);
+  builder_.add_length(length);
+  builder_.add_compression(compression);
+  builder_.add_buffers(buffers);
+  builder_.add_nodes(nodes);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t length = 0,
+    const std::vector<org::apache::arrow::flatbuf::FieldNode> *nodes = nullptr,
+    const std::vector<org::apache::arrow::flatbuf::Buffer> *buffers = nullptr,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::BodyCompression> compression = 0) {
+  auto nodes__ = nodes ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::FieldNode>(*nodes) : 0;
+  auto buffers__ = buffers ? _fbb.CreateVectorOfStructs<org::apache::arrow::flatbuf::Buffer>(*buffers) : 0;
+  return org::apache::arrow::flatbuf::CreateRecordBatch(
+      _fbb,
+      length,
+      nodes__,
+      buffers__,
+      compression);
+}
+
+/// For sending dictionary encoding information. Any Field can be
+/// dictionary-encoded, but in this case none of its children may be
+/// dictionary-encoded.
+/// There is one vector / column per dictionary, but that vector / column
+/// may be spread across multiple dictionary batches by using the isDelta
+/// flag
+struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef DictionaryBatchBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_DATA = 6,
+    VT_ISDELTA = 8
+  };
+  int64_t id() const {
+    return GetField<int64_t>(VT_ID, 0);
+  }
+  const org::apache::arrow::flatbuf::RecordBatch *data() const {
+    return GetPointer<const org::apache::arrow::flatbuf::RecordBatch *>(VT_DATA);
+  }
+  /// If isDelta is true the values in the dictionary are to be appended to a
+  /// dictionary with the indicated id. If isDelta is false this dictionary
+  /// should replace the existing dictionary.
+  bool isDelta() const {
+    return GetField<uint8_t>(VT_ISDELTA, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_ID) &&
+           VerifyOffset(verifier, VT_DATA) &&
+           verifier.VerifyTable(data()) &&
+           VerifyField<uint8_t>(verifier, VT_ISDELTA) &&
+           verifier.EndTable();
+  }
+};
+
+struct DictionaryBatchBuilder {
+  typedef DictionaryBatch Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(int64_t id) {
+    fbb_.AddElement<int64_t>(DictionaryBatch::VT_ID, id, 0);
+  }
+  void add_data(flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data) {
+    fbb_.AddOffset(DictionaryBatch::VT_DATA, data);
+  }
+  void add_isDelta(bool isDelta) {
+    fbb_.AddElement<uint8_t>(DictionaryBatch::VT_ISDELTA, static_cast<uint8_t>(isDelta), 0);
+  }
+  explicit DictionaryBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DictionaryBatchBuilder &operator=(const DictionaryBatchBuilder &);
+  flatbuffers::Offset<DictionaryBatch> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<DictionaryBatch>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<DictionaryBatch> CreateDictionaryBatch(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t id = 0,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::RecordBatch> data = 0,
+    bool isDelta = false) {
+  DictionaryBatchBuilder builder_(_fbb);
+  builder_.add_id(id);
+  builder_.add_data(data);
+  builder_.add_isDelta(isDelta);
+  return builder_.Finish();
+}
+
+struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef MessageBuilder Builder;
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VERSION = 4,
+    VT_HEADER_TYPE = 6,
+    VT_HEADER = 8,
+    VT_BODYLENGTH = 10,
+    VT_CUSTOM_METADATA = 12
+  };
+  org::apache::arrow::flatbuf::MetadataVersion version() const {
+    return static_cast<org::apache::arrow::flatbuf::MetadataVersion>(GetField<int16_t>(VT_VERSION, 0));
+  }
+  org::apache::arrow::flatbuf::MessageHeader header_type() const {
+    return static_cast<org::apache::arrow::flatbuf::MessageHeader>(GetField<uint8_t>(VT_HEADER_TYPE, 0));
+  }
+  const void *header() const {
+    return GetPointer<const void *>(VT_HEADER);
+  }
+  template<typename T> const T *header_as() const;
+  const org::apache::arrow::flatbuf::Schema *header_as_Schema() const {
+    return header_type() == org::apache::arrow::flatbuf::MessageHeader::Schema ? static_cast<const org::apache::arrow::flatbuf::Schema *>(header()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::DictionaryBatch *header_as_DictionaryBatch() const {
+    return header_type() == org::apache::arrow::flatbuf::MessageHeader::DictionaryBatch ? static_cast<const org::apache::arrow::flatbuf::DictionaryBatch *>(header()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::RecordBatch *header_as_RecordBatch() const {
+    return header_type() == org::apache::arrow::flatbuf::MessageHeader::RecordBatch ? static_cast<const org::apache::arrow::flatbuf::RecordBatch *>(header()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::Tensor *header_as_Tensor() const {
+    return header_type() == org::apache::arrow::flatbuf::MessageHeader::Tensor ? static_cast<const org::apache::arrow::flatbuf::Tensor *>(header()) : nullptr;
+  }
+  const org::apache::arrow::flatbuf::SparseTensor *header_as_SparseTensor() const {
+    return header_type() == org::apache::arrow::flatbuf::MessageHeader::SparseTensor ? static_cast<const org::apache::arrow::flatbuf::SparseTensor *>(header()) : nullptr;
+  }
+  int64_t bodyLength() const {
+    return GetField<int64_t>(VT_BODYLENGTH, 0);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *>(VT_CUSTOM_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_VERSION) &&
+           VerifyField<uint8_t>(verifier, VT_HEADER_TYPE) &&
+           VerifyOffset(verifier, VT_HEADER) &&
+           VerifyMessageHeader(verifier, header(), header_type()) &&
+           VerifyField<int64_t>(verifier, VT_BODYLENGTH) &&
+           VerifyOffset(verifier, VT_CUSTOM_METADATA) &&
+           verifier.VerifyVector(custom_metadata()) &&
+           verifier.VerifyVectorOfTables(custom_metadata()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const org::apache::arrow::flatbuf::Schema *Message::header_as<org::apache::arrow::flatbuf::Schema>() const {
+  return header_as_Schema();
+}
+
+template<> inline const org::apache::arrow::flatbuf::DictionaryBatch *Message::header_as<org::apache::arrow::flatbuf::DictionaryBatch>() const {
+  return header_as_DictionaryBatch();
+}
+
+template<> inline const org::apache::arrow::flatbuf::RecordBatch *Message::header_as<org::apache::arrow::flatbuf::RecordBatch>() const {
+  return header_as_RecordBatch();
+}
+
+template<> inline const org::apache::arrow::flatbuf::Tensor *Message::header_as<org::apache::arrow::flatbuf::Tensor>() const {
+  return header_as_Tensor();
+}
+
+template<> inline const org::apache::arrow::flatbuf::SparseTensor *Message::header_as<org::apache::arrow::flatbuf::SparseTensor>() const {
+  return header_as_SparseTensor();
+}
+
+struct MessageBuilder {
+  typedef Message Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_version(org::apache::arrow::flatbuf::MetadataVersion version) {
+    fbb_.AddElement<int16_t>(Message::VT_VERSION, static_cast<int16_t>(version), 0);
+  }
+  void add_header_type(org::apache::arrow::flatbuf::MessageHeader header_type) {
+    fbb_.AddElement<uint8_t>(Message::VT_HEADER_TYPE, static_cast<uint8_t>(header_type), 0);
+  }
+  void add_header(flatbuffers::Offset<void> header) {
+    fbb_.AddOffset(Message::VT_HEADER, header);
+  }
+  void add_bodyLength(int64_t bodyLength) {
+    fbb_.AddElement<int64_t>(Message::VT_BODYLENGTH, bodyLength, 0);
+  }
+  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata) {
+    fbb_.AddOffset(Message::VT_CUSTOM_METADATA, custom_metadata);
+  }
+  explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  MessageBuilder &operator=(const MessageBuilder &);
+  flatbuffers::Offset<Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Message> CreateMessage(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1,
+    org::apache::arrow::flatbuf::MessageHeader header_type = org::apache::arrow::flatbuf::MessageHeader::NONE,
+    flatbuffers::Offset<void> header = 0,
+    int64_t bodyLength = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>> custom_metadata = 0) {
+  MessageBuilder builder_(_fbb);
+  builder_.add_bodyLength(bodyLength);
+  builder_.add_custom_metadata(custom_metadata);
+  builder_.add_header(header);
+  builder_.add_version(version);
+  builder_.add_header_type(header_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Message> CreateMessageDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    org::apache::arrow::flatbuf::MetadataVersion version = org::apache::arrow::flatbuf::MetadataVersion::V1,
+    org::apache::arrow::flatbuf::MessageHeader header_type = org::apache::arrow::flatbuf::MessageHeader::NONE,
+    flatbuffers::Offset<void> header = 0,
+    int64_t bodyLength = 0,
+    const std::vector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>> *custom_metadata = nullptr) {
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<org::apache::arrow::flatbuf::KeyValue>>(*custom_metadata) : 0;
+  return org::apache::arrow::flatbuf::CreateMessage(
+      _fbb,
+      version,
+      header_type,
+      header,
+      bodyLength,
+      custom_metadata__);
+}
+
+inline bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type) {
+  switch (type) {
+    case MessageHeader::NONE: {
+      return true;
+    }
+    case MessageHeader::Schema: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Schema *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader::DictionaryBatch: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::DictionaryBatch *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader::RecordBatch: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::RecordBatch *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader::Tensor: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::Tensor *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader::SparseTensor: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::SparseTensor *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return true;
+  }
+}
+
+inline bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyMessageHeader(
+        verifier,  values->Get(i), types->GetEnum<MessageHeader>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const org::apache::arrow::flatbuf::Message *GetMessage(const void *buf) {
+  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Message>(buf);
+}
+
+inline const org::apache::arrow::flatbuf::Message *GetSizePrefixedMessage(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Message>(buf);
+}
+
+inline bool VerifyMessageBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Message>(nullptr);
+}
+
+inline bool VerifySizePrefixedMessageBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Message>(nullptr);
+}
+
+inline void FinishMessageBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedMessageBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace flatbuf
+}  // namespace arrow
+}  // namespace apache
+}  // namespace org
+
+#endif  // FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_