From 3146588a0c2b016a757d0f3f86d152c814b734e9 Mon Sep 17 00:00:00 2001
From: zagto <tobias@zagorni.eu>
Date: Thu, 12 Jan 2023 16:31:05 +0100
Subject: [PATCH] ARROW-16782: [Format] Add REE definitions to FlatBuffers
 (#14176)

Lead-authored-by: Matt Topol <zotthewizard@gmail.com>
Co-authored-by: Tobias Zagorni <tobias@zagorni.eu>
Co-authored-by: zagto <tobias@zagorni.eu>
Co-authored-by: Andrew Lamb <andrew@nerdnetworks.org>
Co-authored-by: David Li <li.davidm96@gmail.com>
Co-authored-by: Antoine Pitrou <pitrou@free.fr>
Co-authored-by: Weston Pace <weston.pace@gmail.com>
Signed-off-by: Matt Topol <zotthewizard@gmail.com>
---
 cpp/src/generated/File_generated.h         |  10 +-
 cpp/src/generated/Message_generated.h      |  12 +-
 cpp/src/generated/Schema_generated.h       |  95 ++++--
 cpp/src/generated/SparseTensor_generated.h |  11 +-
 cpp/src/generated/Tensor_generated.h       |   9 +-
 cpp/src/generated/feather_generated.h      |   7 -
 cpp/src/plasma/common_generated.h          |  27 +-
 cpp/src/plasma/plasma_generated.h          | 343 +++++++--------------
 docs/source/format/Columnar.rst            |  89 +++++-
 format/Schema.fbs                          |  14 +-
 go/arrow/internal/flatbuf/RunEndEncoded.go |  55 ++++
 go/arrow/internal/flatbuf/Type.go          |   3 +
 12 files changed, 365 insertions(+), 310 deletions(-)
 create mode 100644 go/arrow/internal/flatbuf/RunEndEncoded.go

diff --git a/cpp/src/generated/File_generated.h b/cpp/src/generated/File_generated.h
index 06953c4a04044..5b219f1eb0ed1 100644
--- a/cpp/src/generated/File_generated.h
+++ b/cpp/src/generated/File_generated.h
@@ -26,15 +26,18 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Block FLATBUFFERS_FINAL_CLASS {
   int64_t bodyLength_;
 
  public:
-  Block() {
-    memset(static_cast<void *>(this), 0, sizeof(Block));
+  Block()
+      : offset_(0),
+        metaDataLength_(0),
+        padding0__(0),
+        bodyLength_(0) {
+    (void)padding0__;
   }
   Block(int64_t _offset, int32_t _metaDataLength, int64_t _bodyLength)
       : offset_(flatbuffers::EndianScalar(_offset)),
         metaDataLength_(flatbuffers::EndianScalar(_metaDataLength)),
         padding0__(0),
         bodyLength_(flatbuffers::EndianScalar(_bodyLength)) {
-    (void)padding0__;
   }
   /// Index to the start of the RecordBlock (note this is past the Message header)
   int64_t offset() const {
@@ -119,7 +122,6 @@ struct FooterBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FooterBuilder &operator=(const FooterBuilder &);
   flatbuffers::Offset<Footer> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Footer>(end);
diff --git a/cpp/src/generated/Message_generated.h b/cpp/src/generated/Message_generated.h
index 1c51c6eafb3b7..d0c71e04294a9 100644
--- a/cpp/src/generated/Message_generated.h
+++ b/cpp/src/generated/Message_generated.h
@@ -188,8 +188,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
   int64_t null_count_;
 
  public:
-  FieldNode() {
-    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
+  FieldNode()
+      : length_(0),
+        null_count_(0) {
   }
   FieldNode(int64_t _length, int64_t _null_count)
       : length_(flatbuffers::EndianScalar(_length)),
@@ -218,7 +219,8 @@ struct BodyCompression FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_CODEC = 4,
     VT_METHOD = 6
   };
-  /// Compressor library
+  /// Compressor library.
+  /// For LZ4_FRAME, each compressed buffer must consist of a single frame.
   org::apache::arrow::flatbuf::CompressionType codec() const {
     return static_cast<org::apache::arrow::flatbuf::CompressionType>(GetField<int8_t>(VT_CODEC, 0));
   }
@@ -248,7 +250,6 @@ struct BodyCompressionBuilder {
         : 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);
@@ -332,7 +333,6 @@ struct RecordBatchBuilder {
         : 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);
@@ -422,7 +422,6 @@ struct DictionaryBatchBuilder {
         : 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);
@@ -539,7 +538,6 @@ struct MessageBuilder {
         : 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);
diff --git a/cpp/src/generated/Schema_generated.h b/cpp/src/generated/Schema_generated.h
index 79ffa661e4a6d..89204c894aa4b 100644
--- a/cpp/src/generated/Schema_generated.h
+++ b/cpp/src/generated/Schema_generated.h
@@ -56,6 +56,9 @@ struct FixedSizeBinaryBuilder;
 struct Bool;
 struct BoolBuilder;
 
+struct RunEndEncoded;
+struct RunEndEncodedBuilder;
+
 struct Decimal;
 struct DecimalBuilder;
 
@@ -382,11 +385,12 @@ enum class Type : uint8_t {
   LargeBinary = 19,
   LargeUtf8 = 20,
   LargeList = 21,
+  RunEndEncoded = 22,
   MIN = NONE,
-  MAX = LargeList
+  MAX = RunEndEncoded
 };
 
-inline const Type (&EnumValuesType())[22] {
+inline const Type (&EnumValuesType())[23] {
   static const Type values[] = {
     Type::NONE,
     Type::Null,
@@ -409,13 +413,14 @@ inline const Type (&EnumValuesType())[22] {
     Type::Duration,
     Type::LargeBinary,
     Type::LargeUtf8,
-    Type::LargeList
+    Type::LargeList,
+    Type::RunEndEncoded
   };
   return values;
 }
 
 inline const char * const *EnumNamesType() {
-  static const char * const names[23] = {
+  static const char * const names[24] = {
     "NONE",
     "Null",
     "Int",
@@ -438,13 +443,14 @@ inline const char * const *EnumNamesType() {
     "LargeBinary",
     "LargeUtf8",
     "LargeList",
+    "RunEndEncoded",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameType(Type e) {
-  if (flatbuffers::IsOutRange(e, Type::NONE, Type::LargeList)) return "";
+  if (flatbuffers::IsOutRange(e, Type::NONE, Type::RunEndEncoded)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesType()[index];
 }
@@ -537,6 +543,10 @@ template<> struct TypeTraits<org::apache::arrow::flatbuf::LargeList> {
   static const Type enum_value = Type::LargeList;
 };
 
+template<> struct TypeTraits<org::apache::arrow::flatbuf::RunEndEncoded> {
+  static const Type enum_value = Type::RunEndEncoded;
+};
+
 bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type);
 bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
@@ -612,8 +622,9 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
   int64_t length_;
 
  public:
-  Buffer() {
-    memset(static_cast<void *>(this), 0, sizeof(Buffer));
+  Buffer()
+      : offset_(0),
+        length_(0) {
   }
   Buffer(int64_t _offset, int64_t _length)
       : offset_(flatbuffers::EndianScalar(_offset)),
@@ -652,7 +663,6 @@ struct NullBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  NullBuilder &operator=(const NullBuilder &);
   flatbuffers::Offset<Null> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Null>(end);
@@ -685,7 +695,6 @@ struct Struct_Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  Struct_Builder &operator=(const Struct_Builder &);
   flatbuffers::Offset<Struct_> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Struct_>(end);
@@ -715,7 +724,6 @@ struct ListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ListBuilder &operator=(const ListBuilder &);
   flatbuffers::Offset<List> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<List>(end);
@@ -747,7 +755,6 @@ struct LargeListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeListBuilder &operator=(const LargeListBuilder &);
   flatbuffers::Offset<LargeList> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeList>(end);
@@ -788,7 +795,6 @@ struct FixedSizeListBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FixedSizeListBuilder &operator=(const FixedSizeListBuilder &);
   flatbuffers::Offset<FixedSizeList> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FixedSizeList>(end);
@@ -856,7 +862,6 @@ struct MapBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  MapBuilder &operator=(const MapBuilder &);
   flatbuffers::Offset<Map> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Map>(end);
@@ -911,7 +916,6 @@ struct UnionBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  UnionBuilder &operator=(const UnionBuilder &);
   flatbuffers::Offset<Union> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Union>(end);
@@ -974,7 +978,6 @@ struct IntBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  IntBuilder &operator=(const IntBuilder &);
   flatbuffers::Offset<Int> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Int>(end);
@@ -1018,7 +1021,6 @@ struct FloatingPointBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FloatingPointBuilder &operator=(const FloatingPointBuilder &);
   flatbuffers::Offset<FloatingPoint> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FloatingPoint>(end);
@@ -1051,7 +1053,6 @@ struct Utf8Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  Utf8Builder &operator=(const Utf8Builder &);
   flatbuffers::Offset<Utf8> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Utf8>(end);
@@ -1082,7 +1083,6 @@ struct BinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  BinaryBuilder &operator=(const BinaryBuilder &);
   flatbuffers::Offset<Binary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Binary>(end);
@@ -1114,7 +1114,6 @@ struct LargeUtf8Builder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeUtf8Builder &operator=(const LargeUtf8Builder &);
   flatbuffers::Offset<LargeUtf8> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeUtf8>(end);
@@ -1146,7 +1145,6 @@ struct LargeBinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  LargeBinaryBuilder &operator=(const LargeBinaryBuilder &);
   flatbuffers::Offset<LargeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<LargeBinary>(end);
@@ -1187,7 +1185,6 @@ struct FixedSizeBinaryBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FixedSizeBinaryBuilder &operator=(const FixedSizeBinaryBuilder &);
   flatbuffers::Offset<FixedSizeBinary> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<FixedSizeBinary>(end);
@@ -1219,7 +1216,6 @@ struct BoolBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  BoolBuilder &operator=(const BoolBuilder &);
   flatbuffers::Offset<Bool> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Bool>(end);
@@ -1233,6 +1229,40 @@ inline flatbuffers::Offset<Bool> CreateBool(
   return builder_.Finish();
 }
 
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in 
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+struct RunEndEncoded FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef RunEndEncodedBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct RunEndEncodedBuilder {
+  typedef RunEndEncoded Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit RunEndEncodedBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<RunEndEncoded> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<RunEndEncoded>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<RunEndEncoded> CreateRunEndEncoded(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  RunEndEncodedBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
 /// Exact decimal value represented as an integer value in two's
 /// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
 /// are used. The representation uses the endianness indicated
@@ -1283,7 +1313,6 @@ struct DecimalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DecimalBuilder &operator=(const DecimalBuilder &);
   flatbuffers::Offset<Decimal> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Decimal>(end);
@@ -1335,7 +1364,6 @@ struct DateBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DateBuilder &operator=(const DateBuilder &);
   flatbuffers::Offset<Date> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Date>(end);
@@ -1399,7 +1427,6 @@ struct TimeBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimeBuilder &operator=(const TimeBuilder &);
   flatbuffers::Offset<Time> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Time>(end);
@@ -1567,7 +1594,6 @@ struct TimestampBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimestampBuilder &operator=(const TimestampBuilder &);
   flatbuffers::Offset<Timestamp> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Timestamp>(end);
@@ -1622,7 +1648,6 @@ struct IntervalBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  IntervalBuilder &operator=(const IntervalBuilder &);
   flatbuffers::Offset<Interval> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Interval>(end);
@@ -1664,7 +1689,6 @@ struct DurationBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DurationBuilder &operator=(const DurationBuilder &);
   flatbuffers::Offset<Duration> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Duration>(end);
@@ -1719,7 +1743,6 @@ struct KeyValueBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  KeyValueBuilder &operator=(const KeyValueBuilder &);
   flatbuffers::Offset<KeyValue> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<KeyValue>(end);
@@ -1812,7 +1835,6 @@ struct DictionaryEncodingBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DictionaryEncodingBuilder &operator=(const DictionaryEncodingBuilder &);
   flatbuffers::Offset<DictionaryEncoding> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DictionaryEncoding>(end);
@@ -1927,6 +1949,9 @@ struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::LargeList *type_as_LargeList() const {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeList ? static_cast<const org::apache::arrow::flatbuf::LargeList *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
+  }
   /// Present only if the field is dictionary encoded.
   const org::apache::arrow::flatbuf::DictionaryEncoding *dictionary() const {
     return GetPointer<const org::apache::arrow::flatbuf::DictionaryEncoding *>(VT_DICTIONARY);
@@ -2044,6 +2069,10 @@ template<> inline const org::apache::arrow::flatbuf::LargeList *Field::type_as<o
   return type_as_LargeList();
 }
 
+template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *Field::type_as<org::apache::arrow::flatbuf::RunEndEncoded>() const {
+  return type_as_RunEndEncoded();
+}
+
 struct FieldBuilder {
   typedef Field Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -2073,7 +2102,6 @@ struct FieldBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  FieldBuilder &operator=(const FieldBuilder &);
   flatbuffers::Offset<Field> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Field>(end);
@@ -2185,7 +2213,6 @@ struct SchemaBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SchemaBuilder &operator=(const SchemaBuilder &);
   flatbuffers::Offset<Schema> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Schema>(end);
@@ -2313,6 +2340,10 @@ inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type ty
       auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::LargeList *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case Type::RunEndEncoded: {
+      auto ptr = reinterpret_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }
diff --git a/cpp/src/generated/SparseTensor_generated.h b/cpp/src/generated/SparseTensor_generated.h
index a66269182eabe..b3fa2dbff467d 100644
--- a/cpp/src/generated/SparseTensor_generated.h
+++ b/cpp/src/generated/SparseTensor_generated.h
@@ -204,7 +204,6 @@ struct SparseTensorIndexCOOBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseTensorIndexCOOBuilder &operator=(const SparseTensorIndexCOOBuilder &);
   flatbuffers::Offset<SparseTensorIndexCOO> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensorIndexCOO>(end);
@@ -339,7 +338,6 @@ struct SparseMatrixIndexCSXBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseMatrixIndexCSXBuilder &operator=(const SparseMatrixIndexCSXBuilder &);
   flatbuffers::Offset<SparseMatrixIndexCSX> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseMatrixIndexCSX>(end);
@@ -494,7 +492,6 @@ struct SparseTensorIndexCSFBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseTensorIndexCSFBuilder &operator=(const SparseTensorIndexCSFBuilder &);
   flatbuffers::Offset<SparseTensorIndexCSF> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensorIndexCSF>(end);
@@ -626,6 +623,9 @@ struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::LargeList *type_as_LargeList() const {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeList ? static_cast<const org::apache::arrow::flatbuf::LargeList *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
+  }
   /// The dimensions of the tensor, optionally named.
   const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
@@ -756,6 +756,10 @@ template<> inline const org::apache::arrow::flatbuf::LargeList *SparseTensor::ty
   return type_as_LargeList();
 }
 
+template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *SparseTensor::type_as<org::apache::arrow::flatbuf::RunEndEncoded>() const {
+  return type_as_RunEndEncoded();
+}
+
 template<> inline const org::apache::arrow::flatbuf::SparseTensorIndexCOO *SparseTensor::sparseIndex_as<org::apache::arrow::flatbuf::SparseTensorIndexCOO>() const {
   return sparseIndex_as_SparseTensorIndexCOO();
 }
@@ -797,7 +801,6 @@ struct SparseTensorBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  SparseTensorBuilder &operator=(const SparseTensorBuilder &);
   flatbuffers::Offset<SparseTensor> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<SparseTensor>(end);
diff --git a/cpp/src/generated/Tensor_generated.h b/cpp/src/generated/Tensor_generated.h
index 062a3b91aaafa..572b922e20f08 100644
--- a/cpp/src/generated/Tensor_generated.h
+++ b/cpp/src/generated/Tensor_generated.h
@@ -59,7 +59,6 @@ struct TensorDimBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TensorDimBuilder &operator=(const TensorDimBuilder &);
   flatbuffers::Offset<TensorDim> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TensorDim>(end);
@@ -169,6 +168,9 @@ struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const org::apache::arrow::flatbuf::LargeList *type_as_LargeList() const {
     return type_type() == org::apache::arrow::flatbuf::Type::LargeList ? static_cast<const org::apache::arrow::flatbuf::LargeList *>(type()) : nullptr;
   }
+  const org::apache::arrow::flatbuf::RunEndEncoded *type_as_RunEndEncoded() const {
+    return type_type() == org::apache::arrow::flatbuf::Type::RunEndEncoded ? static_cast<const org::apache::arrow::flatbuf::RunEndEncoded *>(type()) : nullptr;
+  }
   /// The dimensions of the tensor, optionally named
   const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *shape() const {
     return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<org::apache::arrow::flatbuf::TensorDim>> *>(VT_SHAPE);
@@ -281,6 +283,10 @@ template<> inline const org::apache::arrow::flatbuf::LargeList *Tensor::type_as<
   return type_as_LargeList();
 }
 
+template<> inline const org::apache::arrow::flatbuf::RunEndEncoded *Tensor::type_as<org::apache::arrow::flatbuf::RunEndEncoded>() const {
+  return type_as_RunEndEncoded();
+}
+
 struct TensorBuilder {
   typedef Tensor Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -304,7 +310,6 @@ struct TensorBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TensorBuilder &operator=(const TensorBuilder &);
   flatbuffers::Offset<Tensor> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Tensor>(end);
diff --git a/cpp/src/generated/feather_generated.h b/cpp/src/generated/feather_generated.h
index b925eb2bc6a00..3696188b0f55d 100644
--- a/cpp/src/generated/feather_generated.h
+++ b/cpp/src/generated/feather_generated.h
@@ -324,7 +324,6 @@ struct PrimitiveArrayBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PrimitiveArrayBuilder &operator=(const PrimitiveArrayBuilder &);
   flatbuffers::Offset<PrimitiveArray> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PrimitiveArray>(end);
@@ -387,7 +386,6 @@ struct CategoryMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  CategoryMetadataBuilder &operator=(const CategoryMetadataBuilder &);
   flatbuffers::Offset<CategoryMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CategoryMetadata>(end);
@@ -442,7 +440,6 @@ struct TimestampMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimestampMetadataBuilder &operator=(const TimestampMetadataBuilder &);
   flatbuffers::Offset<TimestampMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimestampMetadata>(end);
@@ -487,7 +484,6 @@ struct DateMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  DateMetadataBuilder &operator=(const DateMetadataBuilder &);
   flatbuffers::Offset<DateMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<DateMetadata>(end);
@@ -527,7 +523,6 @@ struct TimeMetadataBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  TimeMetadataBuilder &operator=(const TimeMetadataBuilder &);
   flatbuffers::Offset<TimeMetadata> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<TimeMetadata>(end);
@@ -635,7 +630,6 @@ struct ColumnBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ColumnBuilder &operator=(const ColumnBuilder &);
   flatbuffers::Offset<Column> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<Column>(end);
@@ -745,7 +739,6 @@ struct CTableBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  CTableBuilder &operator=(const CTableBuilder &);
   flatbuffers::Offset<CTable> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CTable>(end);
diff --git a/cpp/src/plasma/common_generated.h b/cpp/src/plasma/common_generated.h
index ba9ef6e72d01a..f9cd881d5486e 100644
--- a/cpp/src/plasma/common_generated.h
+++ b/cpp/src/plasma/common_generated.h
@@ -15,22 +15,14 @@ struct ObjectInfoT;
 
 struct ObjectInfoT : public flatbuffers::NativeTable {
   typedef ObjectInfo TableType;
-  std::string object_id;
-  int64_t data_size;
-  int64_t metadata_size;
-  int32_t ref_count;
-  int64_t create_time;
-  int64_t construct_duration;
-  std::string digest;
-  bool is_deletion;
-  ObjectInfoT()
-      : data_size(0),
-        metadata_size(0),
-        ref_count(0),
-        create_time(0),
-        construct_duration(0),
-        is_deletion(false) {
-  }
+  std::string object_id{};
+  int64_t data_size = 0;
+  int64_t metadata_size = 0;
+  int32_t ref_count = 0;
+  int64_t create_time = 0;
+  int64_t construct_duration = 0;
+  std::string digest{};
+  bool is_deletion = false;
 };
 
 struct ObjectInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -121,7 +113,6 @@ struct ObjectInfoBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  ObjectInfoBuilder &operator=(const ObjectInfoBuilder &);
   flatbuffers::Offset<ObjectInfo> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<ObjectInfo>(end);
@@ -178,7 +169,7 @@ inline flatbuffers::Offset<ObjectInfo> CreateObjectInfoDirect(
 flatbuffers::Offset<ObjectInfo> CreateObjectInfo(flatbuffers::FlatBufferBuilder &_fbb, const ObjectInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
 inline ObjectInfoT *ObjectInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::ObjectInfoT> _o = std::unique_ptr<plasma::flatbuf::ObjectInfoT>(new ObjectInfoT());
+  auto _o = std::unique_ptr<ObjectInfoT>(new ObjectInfoT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
diff --git a/cpp/src/plasma/plasma_generated.h b/cpp/src/plasma/plasma_generated.h
index 340f043bc833c..99e1849e6fd2c 100644
--- a/cpp/src/plasma/plasma_generated.h
+++ b/cpp/src/plasma/plasma_generated.h
@@ -339,8 +339,17 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) PlasmaObjectSpec FLATBUFFERS_FINAL_CLASS
   int32_t padding1__;
 
  public:
-  PlasmaObjectSpec() {
-    memset(static_cast<void *>(this), 0, sizeof(PlasmaObjectSpec));
+  PlasmaObjectSpec()
+      : segment_index_(0),
+        padding0__(0),
+        data_offset_(0),
+        data_size_(0),
+        metadata_offset_(0),
+        metadata_size_(0),
+        device_num_(0),
+        padding1__(0) {
+    (void)padding0__;
+    (void)padding1__;
   }
   PlasmaObjectSpec(int32_t _segment_index, uint64_t _data_offset, uint64_t _data_size, uint64_t _metadata_offset, uint64_t _metadata_size, int32_t _device_num)
       : segment_index_(flatbuffers::EndianScalar(_segment_index)),
@@ -351,8 +360,6 @@ FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) PlasmaObjectSpec FLATBUFFERS_FINAL_CLASS
         metadata_size_(flatbuffers::EndianScalar(_metadata_size)),
         device_num_(flatbuffers::EndianScalar(_device_num)),
         padding1__(0) {
-    (void)padding0__;
-    (void)padding1__;
   }
   int32_t segment_index() const {
     return flatbuffers::EndianScalar(segment_index_);
@@ -377,11 +384,8 @@ FLATBUFFERS_STRUCT_END(PlasmaObjectSpec, 48);
 
 struct PlasmaSetOptionsRequestT : public flatbuffers::NativeTable {
   typedef PlasmaSetOptionsRequest TableType;
-  std::string client_name;
-  int64_t output_memory_quota;
-  PlasmaSetOptionsRequestT()
-      : output_memory_quota(0) {
-  }
+  std::string client_name{};
+  int64_t output_memory_quota = 0;
 };
 
 struct PlasmaSetOptionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -423,7 +427,6 @@ struct PlasmaSetOptionsRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaSetOptionsRequestBuilder &operator=(const PlasmaSetOptionsRequestBuilder &);
   flatbuffers::Offset<PlasmaSetOptionsRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaSetOptionsRequest>(end);
@@ -456,10 +459,7 @@ flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(flatb
 
 struct PlasmaSetOptionsReplyT : public flatbuffers::NativeTable {
   typedef PlasmaSetOptionsReply TableType;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaSetOptionsReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaSetOptionsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -492,7 +492,6 @@ struct PlasmaSetOptionsReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaSetOptionsReplyBuilder &operator=(const PlasmaSetOptionsReplyBuilder &);
   flatbuffers::Offset<PlasmaSetOptionsReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaSetOptionsReply>(end);
@@ -512,8 +511,6 @@ flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(flatbuffe
 
 struct PlasmaGetDebugStringRequestT : public flatbuffers::NativeTable {
   typedef PlasmaGetDebugStringRequest TableType;
-  PlasmaGetDebugStringRequestT() {
-  }
 };
 
 struct PlasmaGetDebugStringRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -536,7 +533,6 @@ struct PlasmaGetDebugStringRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaGetDebugStringRequestBuilder &operator=(const PlasmaGetDebugStringRequestBuilder &);
   flatbuffers::Offset<PlasmaGetDebugStringRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaGetDebugStringRequest>(end);
@@ -554,9 +550,7 @@ flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringReque
 
 struct PlasmaGetDebugStringReplyT : public flatbuffers::NativeTable {
   typedef PlasmaGetDebugStringReply TableType;
-  std::string debug_string;
-  PlasmaGetDebugStringReplyT() {
-  }
+  std::string debug_string{};
 };
 
 struct PlasmaGetDebugStringReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -590,7 +584,6 @@ struct PlasmaGetDebugStringReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaGetDebugStringReplyBuilder &operator=(const PlasmaGetDebugStringReplyBuilder &);
   flatbuffers::Offset<PlasmaGetDebugStringReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaGetDebugStringReply>(end);
@@ -619,17 +612,11 @@ flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(f
 
 struct PlasmaCreateRequestT : public flatbuffers::NativeTable {
   typedef PlasmaCreateRequest TableType;
-  std::string object_id;
-  bool evict_if_full;
-  uint64_t data_size;
-  uint64_t metadata_size;
-  int32_t device_num;
-  PlasmaCreateRequestT()
-      : evict_if_full(false),
-        data_size(0),
-        metadata_size(0),
-        device_num(0) {
-  }
+  std::string object_id{};
+  bool evict_if_full = false;
+  uint64_t data_size = 0;
+  uint64_t metadata_size = 0;
+  int32_t device_num = 0;
 };
 
 struct PlasmaCreateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -695,7 +682,6 @@ struct PlasmaCreateRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaCreateRequestBuilder &operator=(const PlasmaCreateRequestBuilder &);
   flatbuffers::Offset<PlasmaCreateRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaCreateRequest>(end);
@@ -740,9 +726,7 @@ flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbuffers::
 
 struct CudaHandleT : public flatbuffers::NativeTable {
   typedef CudaHandle TableType;
-  std::vector<uint8_t> handle;
-  CudaHandleT() {
-  }
+  std::vector<uint8_t> handle{};
 };
 
 struct CudaHandle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -776,7 +760,6 @@ struct CudaHandleBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  CudaHandleBuilder &operator=(const CudaHandleBuilder &);
   flatbuffers::Offset<CudaHandle> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<CudaHandle>(end);
@@ -805,17 +788,12 @@ flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferBuilder
 
 struct PlasmaCreateReplyT : public flatbuffers::NativeTable {
   typedef PlasmaCreateReply TableType;
-  std::string object_id;
-  std::unique_ptr<plasma::flatbuf::PlasmaObjectSpec> plasma_object;
-  plasma::flatbuf::PlasmaError error;
-  int32_t store_fd;
-  int64_t mmap_size;
-  std::unique_ptr<plasma::flatbuf::CudaHandleT> ipc_handle;
-  PlasmaCreateReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK),
-        store_fd(0),
-        mmap_size(0) {
-  }
+  std::string object_id{};
+  std::unique_ptr<plasma::flatbuf::PlasmaObjectSpec> plasma_object{};
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
+  int32_t store_fd = 0;
+  int64_t mmap_size = 0;
+  std::unique_ptr<plasma::flatbuf::CudaHandleT> ipc_handle{};
 };
 
 struct PlasmaCreateReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -890,7 +868,6 @@ struct PlasmaCreateReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaCreateReplyBuilder &operator=(const PlasmaCreateReplyBuilder &);
   flatbuffers::Offset<PlasmaCreateReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaCreateReply>(end);
@@ -939,14 +916,11 @@ flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffers::Flat
 
 struct PlasmaCreateAndSealRequestT : public flatbuffers::NativeTable {
   typedef PlasmaCreateAndSealRequest TableType;
-  std::string object_id;
-  bool evict_if_full;
-  std::string data;
-  std::string metadata;
-  std::string digest;
-  PlasmaCreateAndSealRequestT()
-      : evict_if_full(false) {
-  }
+  std::string object_id{};
+  bool evict_if_full = false;
+  std::string data{};
+  std::string metadata{};
+  std::string digest{};
 };
 
 struct PlasmaCreateAndSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1015,7 +989,6 @@ struct PlasmaCreateAndSealRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaCreateAndSealRequestBuilder &operator=(const PlasmaCreateAndSealRequestBuilder &);
   flatbuffers::Offset<PlasmaCreateAndSealRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaCreateAndSealRequest>(end);
@@ -1063,10 +1036,7 @@ flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest
 
 struct PlasmaCreateAndSealReplyT : public flatbuffers::NativeTable {
   typedef PlasmaCreateAndSealReply TableType;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaCreateAndSealReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaCreateAndSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1099,7 +1069,6 @@ struct PlasmaCreateAndSealReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaCreateAndSealReplyBuilder &operator=(const PlasmaCreateAndSealReplyBuilder &);
   flatbuffers::Offset<PlasmaCreateAndSealReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaCreateAndSealReply>(end);
@@ -1119,14 +1088,11 @@ flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(fla
 
 struct PlasmaCreateAndSealBatchRequestT : public flatbuffers::NativeTable {
   typedef PlasmaCreateAndSealBatchRequest TableType;
-  std::vector<std::string> object_ids;
-  bool evict_if_full;
-  std::vector<std::string> data;
-  std::vector<std::string> metadata;
-  std::vector<std::string> digest;
-  PlasmaCreateAndSealBatchRequestT()
-      : evict_if_full(false) {
-  }
+  std::vector<std::string> object_ids{};
+  bool evict_if_full = false;
+  std::vector<std::string> data{};
+  std::vector<std::string> metadata{};
+  std::vector<std::string> digest{};
 };
 
 struct PlasmaCreateAndSealBatchRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1199,7 +1165,6 @@ struct PlasmaCreateAndSealBatchRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaCreateAndSealBatchRequestBuilder &operator=(const PlasmaCreateAndSealBatchRequestBuilder &);
   flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaCreateAndSealBatchRequest>(end);
@@ -1247,10 +1212,7 @@ flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBa
 
 struct PlasmaCreateAndSealBatchReplyT : public flatbuffers::NativeTable {
   typedef PlasmaCreateAndSealBatchReply TableType;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaCreateAndSealBatchReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaCreateAndSealBatchReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1283,7 +1245,6 @@ struct PlasmaCreateAndSealBatchReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaCreateAndSealBatchReplyBuilder &operator=(const PlasmaCreateAndSealBatchReplyBuilder &);
   flatbuffers::Offset<PlasmaCreateAndSealBatchReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaCreateAndSealBatchReply>(end);
@@ -1303,9 +1264,7 @@ flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatc
 
 struct PlasmaAbortRequestT : public flatbuffers::NativeTable {
   typedef PlasmaAbortRequest TableType;
-  std::string object_id;
-  PlasmaAbortRequestT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaAbortRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1339,7 +1298,6 @@ struct PlasmaAbortRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaAbortRequestBuilder &operator=(const PlasmaAbortRequestBuilder &);
   flatbuffers::Offset<PlasmaAbortRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaAbortRequest>(end);
@@ -1368,9 +1326,7 @@ flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuffers::Fl
 
 struct PlasmaAbortReplyT : public flatbuffers::NativeTable {
   typedef PlasmaAbortReply TableType;
-  std::string object_id;
-  PlasmaAbortReplyT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaAbortReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1404,7 +1360,6 @@ struct PlasmaAbortReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaAbortReplyBuilder &operator=(const PlasmaAbortReplyBuilder &);
   flatbuffers::Offset<PlasmaAbortReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaAbortReply>(end);
@@ -1433,10 +1388,8 @@ flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers::FlatBu
 
 struct PlasmaSealRequestT : public flatbuffers::NativeTable {
   typedef PlasmaSealRequest TableType;
-  std::string object_id;
-  std::string digest;
-  PlasmaSealRequestT() {
-  }
+  std::string object_id{};
+  std::string digest{};
 };
 
 struct PlasmaSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1479,7 +1432,6 @@ struct PlasmaSealRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaSealRequestBuilder &operator=(const PlasmaSealRequestBuilder &);
   flatbuffers::Offset<PlasmaSealRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaSealRequest>(end);
@@ -1513,11 +1465,8 @@ flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffers::Flat
 
 struct PlasmaSealReplyT : public flatbuffers::NativeTable {
   typedef PlasmaSealReply TableType;
-  std::string object_id;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaSealReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  std::string object_id{};
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1559,7 +1508,6 @@ struct PlasmaSealReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaSealReplyBuilder &operator=(const PlasmaSealReplyBuilder &);
   flatbuffers::Offset<PlasmaSealReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaSealReply>(end);
@@ -1592,11 +1540,8 @@ flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::FlatBuff
 
 struct PlasmaGetRequestT : public flatbuffers::NativeTable {
   typedef PlasmaGetRequest TableType;
-  std::vector<std::string> object_ids;
-  int64_t timeout_ms;
-  PlasmaGetRequestT()
-      : timeout_ms(0) {
-  }
+  std::vector<std::string> object_ids{};
+  int64_t timeout_ms = 0;
 };
 
 struct PlasmaGetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1639,7 +1584,6 @@ struct PlasmaGetRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaGetRequestBuilder &operator=(const PlasmaGetRequestBuilder &);
   flatbuffers::Offset<PlasmaGetRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaGetRequest>(end);
@@ -1672,13 +1616,11 @@ flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers::FlatBu
 
 struct PlasmaGetReplyT : public flatbuffers::NativeTable {
   typedef PlasmaGetReply TableType;
-  std::vector<std::string> object_ids;
-  std::vector<plasma::flatbuf::PlasmaObjectSpec> plasma_objects;
-  std::vector<int32_t> store_fds;
-  std::vector<int64_t> mmap_sizes;
-  std::vector<std::unique_ptr<plasma::flatbuf::CudaHandleT>> handles;
-  PlasmaGetReplyT() {
-  }
+  std::vector<std::string> object_ids{};
+  std::vector<plasma::flatbuf::PlasmaObjectSpec> plasma_objects{};
+  std::vector<int32_t> store_fds{};
+  std::vector<int64_t> mmap_sizes{};
+  std::vector<std::unique_ptr<plasma::flatbuf::CudaHandleT>> handles{};
 };
 
 struct PlasmaGetReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1750,7 +1692,6 @@ struct PlasmaGetReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaGetReplyBuilder &operator=(const PlasmaGetReplyBuilder &);
   flatbuffers::Offset<PlasmaGetReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaGetReply>(end);
@@ -1799,9 +1740,7 @@ flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::FlatBuffer
 
 struct PlasmaReleaseRequestT : public flatbuffers::NativeTable {
   typedef PlasmaReleaseRequest TableType;
-  std::string object_id;
-  PlasmaReleaseRequestT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaReleaseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1835,7 +1774,6 @@ struct PlasmaReleaseRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaReleaseRequestBuilder &operator=(const PlasmaReleaseRequestBuilder &);
   flatbuffers::Offset<PlasmaReleaseRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaReleaseRequest>(end);
@@ -1864,11 +1802,8 @@ flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flatbuffers
 
 struct PlasmaReleaseReplyT : public flatbuffers::NativeTable {
   typedef PlasmaReleaseReply TableType;
-  std::string object_id;
-  plasma::flatbuf::PlasmaError error;
-  PlasmaReleaseReplyT()
-      : error(plasma::flatbuf::PlasmaError::OK) {
-  }
+  std::string object_id{};
+  plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK;
 };
 
 struct PlasmaReleaseReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1910,7 +1845,6 @@ struct PlasmaReleaseReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaReleaseReplyBuilder &operator=(const PlasmaReleaseReplyBuilder &);
   flatbuffers::Offset<PlasmaReleaseReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaReleaseReply>(end);
@@ -1943,11 +1877,8 @@ flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuffers::Fl
 
 struct PlasmaDeleteRequestT : public flatbuffers::NativeTable {
   typedef PlasmaDeleteRequest TableType;
-  int32_t count;
-  std::vector<std::string> object_ids;
-  PlasmaDeleteRequestT()
-      : count(0) {
-  }
+  int32_t count = 0;
+  std::vector<std::string> object_ids{};
 };
 
 struct PlasmaDeleteRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -1990,7 +1921,6 @@ struct PlasmaDeleteRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaDeleteRequestBuilder &operator=(const PlasmaDeleteRequestBuilder &);
   flatbuffers::Offset<PlasmaDeleteRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaDeleteRequest>(end);
@@ -2023,12 +1953,9 @@ flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbuffers::
 
 struct PlasmaDeleteReplyT : public flatbuffers::NativeTable {
   typedef PlasmaDeleteReply TableType;
-  int32_t count;
-  std::vector<std::string> object_ids;
-  std::vector<plasma::flatbuf::PlasmaError> errors;
-  PlasmaDeleteReplyT()
-      : count(0) {
-  }
+  int32_t count = 0;
+  std::vector<std::string> object_ids{};
+  std::vector<plasma::flatbuf::PlasmaError> errors{};
 };
 
 struct PlasmaDeleteReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2080,7 +2007,6 @@ struct PlasmaDeleteReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaDeleteReplyBuilder &operator=(const PlasmaDeleteReplyBuilder &);
   flatbuffers::Offset<PlasmaDeleteReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaDeleteReply>(end);
@@ -2118,9 +2044,7 @@ flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffers::Flat
 
 struct PlasmaContainsRequestT : public flatbuffers::NativeTable {
   typedef PlasmaContainsRequest TableType;
-  std::string object_id;
-  PlasmaContainsRequestT() {
-  }
+  std::string object_id{};
 };
 
 struct PlasmaContainsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2154,7 +2078,6 @@ struct PlasmaContainsRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaContainsRequestBuilder &operator=(const PlasmaContainsRequestBuilder &);
   flatbuffers::Offset<PlasmaContainsRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaContainsRequest>(end);
@@ -2183,11 +2106,8 @@ flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(flatbuffe
 
 struct PlasmaContainsReplyT : public flatbuffers::NativeTable {
   typedef PlasmaContainsReply TableType;
-  std::string object_id;
-  int32_t has_object;
-  PlasmaContainsReplyT()
-      : has_object(0) {
-  }
+  std::string object_id{};
+  int32_t has_object = 0;
 };
 
 struct PlasmaContainsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2229,7 +2149,6 @@ struct PlasmaContainsReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaContainsReplyBuilder &operator=(const PlasmaContainsReplyBuilder &);
   flatbuffers::Offset<PlasmaContainsReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaContainsReply>(end);
@@ -2262,8 +2181,6 @@ flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::
 
 struct PlasmaListRequestT : public flatbuffers::NativeTable {
   typedef PlasmaListRequest TableType;
-  PlasmaListRequestT() {
-  }
 };
 
 struct PlasmaListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2286,7 +2203,6 @@ struct PlasmaListRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaListRequestBuilder &operator=(const PlasmaListRequestBuilder &);
   flatbuffers::Offset<PlasmaListRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaListRequest>(end);
@@ -2304,9 +2220,7 @@ flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffers::Flat
 
 struct PlasmaListReplyT : public flatbuffers::NativeTable {
   typedef PlasmaListReply TableType;
-  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> objects;
-  PlasmaListReplyT() {
-  }
+  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> objects{};
 };
 
 struct PlasmaListReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2341,7 +2255,6 @@ struct PlasmaListReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaListReplyBuilder &operator=(const PlasmaListReplyBuilder &);
   flatbuffers::Offset<PlasmaListReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaListReply>(end);
@@ -2370,8 +2283,6 @@ flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::FlatBuff
 
 struct PlasmaConnectRequestT : public flatbuffers::NativeTable {
   typedef PlasmaConnectRequest TableType;
-  PlasmaConnectRequestT() {
-  }
 };
 
 struct PlasmaConnectRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2394,7 +2305,6 @@ struct PlasmaConnectRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaConnectRequestBuilder &operator=(const PlasmaConnectRequestBuilder &);
   flatbuffers::Offset<PlasmaConnectRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaConnectRequest>(end);
@@ -2412,10 +2322,7 @@ flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flatbuffers
 
 struct PlasmaConnectReplyT : public flatbuffers::NativeTable {
   typedef PlasmaConnectReply TableType;
-  int64_t memory_capacity;
-  PlasmaConnectReplyT()
-      : memory_capacity(0) {
-  }
+  int64_t memory_capacity = 0;
 };
 
 struct PlasmaConnectReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2448,7 +2355,6 @@ struct PlasmaConnectReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaConnectReplyBuilder &operator=(const PlasmaConnectReplyBuilder &);
   flatbuffers::Offset<PlasmaConnectReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaConnectReply>(end);
@@ -2468,10 +2374,7 @@ flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuffers::Fl
 
 struct PlasmaEvictRequestT : public flatbuffers::NativeTable {
   typedef PlasmaEvictRequest TableType;
-  uint64_t num_bytes;
-  PlasmaEvictRequestT()
-      : num_bytes(0) {
-  }
+  uint64_t num_bytes = 0;
 };
 
 struct PlasmaEvictRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2504,7 +2407,6 @@ struct PlasmaEvictRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaEvictRequestBuilder &operator=(const PlasmaEvictRequestBuilder &);
   flatbuffers::Offset<PlasmaEvictRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaEvictRequest>(end);
@@ -2524,10 +2426,7 @@ flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuffers::Fl
 
 struct PlasmaEvictReplyT : public flatbuffers::NativeTable {
   typedef PlasmaEvictReply TableType;
-  uint64_t num_bytes;
-  PlasmaEvictReplyT()
-      : num_bytes(0) {
-  }
+  uint64_t num_bytes = 0;
 };
 
 struct PlasmaEvictReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2560,7 +2459,6 @@ struct PlasmaEvictReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaEvictReplyBuilder &operator=(const PlasmaEvictReplyBuilder &);
   flatbuffers::Offset<PlasmaEvictReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaEvictReply>(end);
@@ -2580,8 +2478,6 @@ flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers::FlatBu
 
 struct PlasmaSubscribeRequestT : public flatbuffers::NativeTable {
   typedef PlasmaSubscribeRequest TableType;
-  PlasmaSubscribeRequestT() {
-  }
 };
 
 struct PlasmaSubscribeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2604,7 +2500,6 @@ struct PlasmaSubscribeRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaSubscribeRequestBuilder &operator=(const PlasmaSubscribeRequestBuilder &);
   flatbuffers::Offset<PlasmaSubscribeRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaSubscribeRequest>(end);
@@ -2622,9 +2517,7 @@ flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(flatbuf
 
 struct PlasmaNotificationT : public flatbuffers::NativeTable {
   typedef PlasmaNotification TableType;
-  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> object_info;
-  PlasmaNotificationT() {
-  }
+  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> object_info{};
 };
 
 struct PlasmaNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2659,7 +2552,6 @@ struct PlasmaNotificationBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaNotificationBuilder &operator=(const PlasmaNotificationBuilder &);
   flatbuffers::Offset<PlasmaNotification> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaNotification>(end);
@@ -2688,12 +2580,9 @@ flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuffers::Fl
 
 struct PlasmaDataRequestT : public flatbuffers::NativeTable {
   typedef PlasmaDataRequest TableType;
-  std::string object_id;
-  std::string address;
-  int32_t port;
-  PlasmaDataRequestT()
-      : port(0) {
-  }
+  std::string object_id{};
+  std::string address{};
+  int32_t port = 0;
 };
 
 struct PlasmaDataRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2744,7 +2633,6 @@ struct PlasmaDataRequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaDataRequestBuilder &operator=(const PlasmaDataRequestBuilder &);
   flatbuffers::Offset<PlasmaDataRequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaDataRequest>(end);
@@ -2782,13 +2670,9 @@ flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffers::Flat
 
 struct PlasmaDataReplyT : public flatbuffers::NativeTable {
   typedef PlasmaDataReply TableType;
-  std::string object_id;
-  uint64_t object_size;
-  uint64_t metadata_size;
-  PlasmaDataReplyT()
-      : object_size(0),
-        metadata_size(0) {
-  }
+  std::string object_id{};
+  uint64_t object_size = 0;
+  uint64_t metadata_size = 0;
 };
 
 struct PlasmaDataReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2838,7 +2722,6 @@ struct PlasmaDataReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaDataReplyBuilder &operator=(const PlasmaDataReplyBuilder &);
   flatbuffers::Offset<PlasmaDataReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaDataReply>(end);
@@ -2875,9 +2758,7 @@ flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::FlatBuff
 
 struct PlasmaRefreshLRURequestT : public flatbuffers::NativeTable {
   typedef PlasmaRefreshLRURequest TableType;
-  std::vector<std::string> object_ids;
-  PlasmaRefreshLRURequestT() {
-  }
+  std::vector<std::string> object_ids{};
 };
 
 struct PlasmaRefreshLRURequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2912,7 +2793,6 @@ struct PlasmaRefreshLRURequestBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaRefreshLRURequestBuilder &operator=(const PlasmaRefreshLRURequestBuilder &);
   flatbuffers::Offset<PlasmaRefreshLRURequest> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaRefreshLRURequest>(end);
@@ -2941,8 +2821,6 @@ flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(flatb
 
 struct PlasmaRefreshLRUReplyT : public flatbuffers::NativeTable {
   typedef PlasmaRefreshLRUReply TableType;
-  PlasmaRefreshLRUReplyT() {
-  }
 };
 
 struct PlasmaRefreshLRUReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -2965,7 +2843,6 @@ struct PlasmaRefreshLRUReplyBuilder {
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
   }
-  PlasmaRefreshLRUReplyBuilder &operator=(const PlasmaRefreshLRUReplyBuilder &);
   flatbuffers::Offset<PlasmaRefreshLRUReply> Finish() {
     const auto end = fbb_.EndTable(start_);
     auto o = flatbuffers::Offset<PlasmaRefreshLRUReply>(end);
@@ -2982,7 +2859,7 @@ inline flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(
 flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
 inline PlasmaSetOptionsRequestT *PlasmaSetOptionsRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsRequestT>(new PlasmaSetOptionsRequestT());
+  auto _o = std::unique_ptr<PlasmaSetOptionsRequestT>(new PlasmaSetOptionsRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3011,7 +2888,7 @@ inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsReques
 }
 
 inline PlasmaSetOptionsReplyT *PlasmaSetOptionsReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSetOptionsReplyT>(new PlasmaSetOptionsReplyT());
+  auto _o = std::unique_ptr<PlasmaSetOptionsReplyT>(new PlasmaSetOptionsReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3037,7 +2914,7 @@ inline flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(fl
 }
 
 inline PlasmaGetDebugStringRequestT *PlasmaGetDebugStringRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringRequestT>(new PlasmaGetDebugStringRequestT());
+  auto _o = std::unique_ptr<PlasmaGetDebugStringRequestT>(new PlasmaGetDebugStringRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3060,7 +2937,7 @@ inline flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStri
 }
 
 inline PlasmaGetDebugStringReplyT *PlasmaGetDebugStringReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetDebugStringReplyT>(new PlasmaGetDebugStringReplyT());
+  auto _o = std::unique_ptr<PlasmaGetDebugStringReplyT>(new PlasmaGetDebugStringReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3086,7 +2963,7 @@ inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugString
 }
 
 inline PlasmaCreateRequestT *PlasmaCreateRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaCreateRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateRequestT>(new PlasmaCreateRequestT());
+  auto _o = std::unique_ptr<PlasmaCreateRequestT>(new PlasmaCreateRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3124,7 +3001,7 @@ inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbu
 }
 
 inline CudaHandleT *CudaHandle::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::CudaHandleT> _o = std::unique_ptr<plasma::flatbuf::CudaHandleT>(new CudaHandleT());
+  auto _o = std::unique_ptr<CudaHandleT>(new CudaHandleT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3150,7 +3027,7 @@ inline flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferB
 }
 
 inline PlasmaCreateReplyT *PlasmaCreateReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaCreateReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateReplyT>(new PlasmaCreateReplyT());
+  auto _o = std::unique_ptr<PlasmaCreateReplyT>(new PlasmaCreateReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3191,7 +3068,7 @@ inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffer
 }
 
 inline PlasmaCreateAndSealRequestT *PlasmaCreateAndSealRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealRequestT>(new PlasmaCreateAndSealRequestT());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealRequestT>(new PlasmaCreateAndSealRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3229,7 +3106,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSeal
 }
 
 inline PlasmaCreateAndSealReplyT *PlasmaCreateAndSealReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealReplyT>(new PlasmaCreateAndSealReplyT());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealReplyT>(new PlasmaCreateAndSealReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3255,7 +3132,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealRe
 }
 
 inline PlasmaCreateAndSealBatchRequestT *PlasmaCreateAndSealBatchRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchRequestT>(new PlasmaCreateAndSealBatchRequestT());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealBatchRequestT>(new PlasmaCreateAndSealBatchRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3293,7 +3170,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAn
 }
 
 inline PlasmaCreateAndSealBatchReplyT *PlasmaCreateAndSealBatchReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaCreateAndSealBatchReplyT>(new PlasmaCreateAndSealBatchReplyT());
+  auto _o = std::unique_ptr<PlasmaCreateAndSealBatchReplyT>(new PlasmaCreateAndSealBatchReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3319,7 +3196,7 @@ inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndS
 }
 
 inline PlasmaAbortRequestT *PlasmaAbortRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaAbortRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaAbortRequestT>(new PlasmaAbortRequestT());
+  auto _o = std::unique_ptr<PlasmaAbortRequestT>(new PlasmaAbortRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3345,7 +3222,7 @@ inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuff
 }
 
 inline PlasmaAbortReplyT *PlasmaAbortReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaAbortReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaAbortReplyT>(new PlasmaAbortReplyT());
+  auto _o = std::unique_ptr<PlasmaAbortReplyT>(new PlasmaAbortReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3371,7 +3248,7 @@ inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers:
 }
 
 inline PlasmaSealRequestT *PlasmaSealRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaSealRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSealRequestT>(new PlasmaSealRequestT());
+  auto _o = std::unique_ptr<PlasmaSealRequestT>(new PlasmaSealRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3400,7 +3277,7 @@ inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffer
 }
 
 inline PlasmaSealReplyT *PlasmaSealReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaSealReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSealReplyT>(new PlasmaSealReplyT());
+  auto _o = std::unique_ptr<PlasmaSealReplyT>(new PlasmaSealReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3429,7 +3306,7 @@ inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::F
 }
 
 inline PlasmaGetRequestT *PlasmaGetRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaGetRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetRequestT>(new PlasmaGetRequestT());
+  auto _o = std::unique_ptr<PlasmaGetRequestT>(new PlasmaGetRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3458,7 +3335,7 @@ inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers:
 }
 
 inline PlasmaGetReplyT *PlasmaGetReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaGetReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaGetReplyT>(new PlasmaGetReplyT());
+  auto _o = std::unique_ptr<PlasmaGetReplyT>(new PlasmaGetReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3496,7 +3373,7 @@ inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::Fla
 }
 
 inline PlasmaReleaseRequestT *PlasmaReleaseRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaReleaseRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaReleaseRequestT>(new PlasmaReleaseRequestT());
+  auto _o = std::unique_ptr<PlasmaReleaseRequestT>(new PlasmaReleaseRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3522,7 +3399,7 @@ inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flat
 }
 
 inline PlasmaReleaseReplyT *PlasmaReleaseReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaReleaseReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaReleaseReplyT>(new PlasmaReleaseReplyT());
+  auto _o = std::unique_ptr<PlasmaReleaseReplyT>(new PlasmaReleaseReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3551,7 +3428,7 @@ inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuff
 }
 
 inline PlasmaDeleteRequestT *PlasmaDeleteRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaDeleteRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDeleteRequestT>(new PlasmaDeleteRequestT());
+  auto _o = std::unique_ptr<PlasmaDeleteRequestT>(new PlasmaDeleteRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3580,7 +3457,7 @@ inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbu
 }
 
 inline PlasmaDeleteReplyT *PlasmaDeleteReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaDeleteReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDeleteReplyT>(new PlasmaDeleteReplyT());
+  auto _o = std::unique_ptr<PlasmaDeleteReplyT>(new PlasmaDeleteReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3612,7 +3489,7 @@ inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffer
 }
 
 inline PlasmaContainsRequestT *PlasmaContainsRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaContainsRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaContainsRequestT>(new PlasmaContainsRequestT());
+  auto _o = std::unique_ptr<PlasmaContainsRequestT>(new PlasmaContainsRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3638,7 +3515,7 @@ inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(fl
 }
 
 inline PlasmaContainsReplyT *PlasmaContainsReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaContainsReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaContainsReplyT>(new PlasmaContainsReplyT());
+  auto _o = std::unique_ptr<PlasmaContainsReplyT>(new PlasmaContainsReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3667,7 +3544,7 @@ inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbu
 }
 
 inline PlasmaListRequestT *PlasmaListRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaListRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaListRequestT>(new PlasmaListRequestT());
+  auto _o = std::unique_ptr<PlasmaListRequestT>(new PlasmaListRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3690,7 +3567,7 @@ inline flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffer
 }
 
 inline PlasmaListReplyT *PlasmaListReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaListReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaListReplyT>(new PlasmaListReplyT());
+  auto _o = std::unique_ptr<PlasmaListReplyT>(new PlasmaListReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3716,7 +3593,7 @@ inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::F
 }
 
 inline PlasmaConnectRequestT *PlasmaConnectRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaConnectRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaConnectRequestT>(new PlasmaConnectRequestT());
+  auto _o = std::unique_ptr<PlasmaConnectRequestT>(new PlasmaConnectRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3739,7 +3616,7 @@ inline flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flat
 }
 
 inline PlasmaConnectReplyT *PlasmaConnectReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaConnectReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaConnectReplyT>(new PlasmaConnectReplyT());
+  auto _o = std::unique_ptr<PlasmaConnectReplyT>(new PlasmaConnectReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3765,7 +3642,7 @@ inline flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuff
 }
 
 inline PlasmaEvictRequestT *PlasmaEvictRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaEvictRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaEvictRequestT>(new PlasmaEvictRequestT());
+  auto _o = std::unique_ptr<PlasmaEvictRequestT>(new PlasmaEvictRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3791,7 +3668,7 @@ inline flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuff
 }
 
 inline PlasmaEvictReplyT *PlasmaEvictReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaEvictReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaEvictReplyT>(new PlasmaEvictReplyT());
+  auto _o = std::unique_ptr<PlasmaEvictReplyT>(new PlasmaEvictReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3817,7 +3694,7 @@ inline flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers:
 }
 
 inline PlasmaSubscribeRequestT *PlasmaSubscribeRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaSubscribeRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaSubscribeRequestT>(new PlasmaSubscribeRequestT());
+  auto _o = std::unique_ptr<PlasmaSubscribeRequestT>(new PlasmaSubscribeRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3840,7 +3717,7 @@ inline flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(
 }
 
 inline PlasmaNotificationT *PlasmaNotification::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaNotificationT> _o = std::unique_ptr<plasma::flatbuf::PlasmaNotificationT>(new PlasmaNotificationT());
+  auto _o = std::unique_ptr<PlasmaNotificationT>(new PlasmaNotificationT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3866,7 +3743,7 @@ inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuff
 }
 
 inline PlasmaDataRequestT *PlasmaDataRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaDataRequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDataRequestT>(new PlasmaDataRequestT());
+  auto _o = std::unique_ptr<PlasmaDataRequestT>(new PlasmaDataRequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3898,7 +3775,7 @@ inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffer
 }
 
 inline PlasmaDataReplyT *PlasmaDataReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaDataReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaDataReplyT>(new PlasmaDataReplyT());
+  auto _o = std::unique_ptr<PlasmaDataReplyT>(new PlasmaDataReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3930,7 +3807,7 @@ inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::F
 }
 
 inline PlasmaRefreshLRURequestT *PlasmaRefreshLRURequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRURequestT> _o = std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRURequestT>(new PlasmaRefreshLRURequestT());
+  auto _o = std::unique_ptr<PlasmaRefreshLRURequestT>(new PlasmaRefreshLRURequestT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
@@ -3956,7 +3833,7 @@ inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRUReques
 }
 
 inline PlasmaRefreshLRUReplyT *PlasmaRefreshLRUReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
-  std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRUReplyT> _o = std::unique_ptr<plasma::flatbuf::PlasmaRefreshLRUReplyT>(new PlasmaRefreshLRUReplyT());
+  auto _o = std::unique_ptr<PlasmaRefreshLRUReplyT>(new PlasmaRefreshLRUReplyT());
   UnPackTo(_o.get(), _resolver);
   return _o.release();
 }
diff --git a/docs/source/format/Columnar.rst b/docs/source/format/Columnar.rst
index 696ed8c03cb22..578b234301ca0 100644
--- a/docs/source/format/Columnar.rst
+++ b/docs/source/format/Columnar.rst
@@ -21,7 +21,7 @@
 Arrow Columnar Format
 *********************
 
-*Version: 1.0*
+*Version: 1.3*
 
 The "Arrow Columnar Format" includes a language-agnostic in-memory
 data structure specification, metadata serialization, and a protocol
@@ -120,6 +120,12 @@ the different physical layouts defined by Arrow:
 * **Sparse** and **Dense Union**: a nested layout representing a
   sequence of values, each of which can have type chosen from a
   collection of child array types.
+* **Dictionary-Encoded**: a layout consisting of a sequence of
+  integers (any bit-width) which represent indexes into a dictionary
+  which could be of any type.
+* **Run-End Encoded (REE)**: a nested layout consisting of two child arrays,
+  one representing values, and one representing the logical index where
+  the run of a corresponding value ends.
 * **Null**: a sequence of all null values, having null logical type
 
 The Arrow columnar memory layout only applies to *data* and not
@@ -319,6 +325,8 @@ Generally the first slot in the offsets array is 0, and the last slot
 is the length of the values array. When serializing this layout, we
 recommend normalizing the offsets to start at 0.
 
+.. _variable-size-list-layout:
+
 Variable-size List Layout
 -------------------------
 
@@ -765,6 +773,84 @@ application.
 We discuss dictionary encoding as it relates to serialization further
 below.
 
+.. _run-end-encoded-layout:
+
+Run-End Encoded Layout
+----------------------
+
+Run-end encoding (REE) is a variation of run-length encoding (RLE). These
+encodings are well-suited for representing data containing sequences of the
+same value, called runs. In run-end encoding, each run is represented as a
+value and an integer giving the index in the array where the run ends.
+
+Any array can be run-end encoded. A run-end encoded array has no buffers
+by itself, but has two child arrays. The first child array, called the run ends array,
+holds either 16, 32, or 64-bit signed integers. The actual values of each run
+are held in the second child array.
+For the purposes of determining field names and schemas, these child arrays
+are prescribed the standard names of **run_ends** and **values** respectively.
+
+The values in the first child array represent the accumulated length of all runs 
+from the first to the current one, i.e. the logical index where the
+current run ends. This allows relatively efficient random access from a logical
+index using binary search. The length of an individual run can be determined by
+subtracting two adjacent values. (Contrast this with run-length encoding, in
+which the lengths of the runs are represented directly, and in which random
+access is less efficient.) 
+
+.. note::
+   Because the ``run_ends`` child array cannot have nulls, it's reasonable
+   to consider why the ``run_ends`` are a child array instead of just a
+   buffer, like the offsets for a :ref:`variable-size-list-layout`. This
+   layout was considered, but it was decided to use the child arrays. 
+
+   Child arrays allow us to keep the "logical length" (the decoded length)
+   associated with the parent array and the "physical length" (the number
+   of run ends) associated with the child arrays.  If ``run_ends`` was a
+   buffer in the parent array then the size of the buffer would be unrelated
+   to the length of the array and this would be confusing.
+
+
+A run must have have a length of at least 1. This means the values in the
+run ends array all are positive and in strictly ascending order. A run end cannot be
+null.
+
+As an example, you could have the following data: ::
+
+    type: Float32
+    [1.0, 1.0, 1.0, 1.0, null, null, 2.0]
+
+In Run-end-encoded form, this could appear as:
+
+::
+
+    * Length: 7, Null count: 2
+    * Child Arrays:
+
+      * run_ends (Int32):
+        * Length: 3, Null count: 0 (Run Ends cannot be null)
+        * Validity bitmap buffer: Not required (if it exists, it should be all 1s)
+        * Values buffer
+
+          | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-63           |
+          |-------------|-------------|-------------|-----------------------|
+          | 4           | 6           | 7           | unspecified (padding) |
+
+      * values (Float32):
+        * Length: 3, Null count: 1
+        * Validity bitmap buffer:
+
+          | Byte 0 (validity bitmap) | Bytes 1-63            |
+          |--------------------------|-----------------------|
+          | 00000101                 | 0 (padding)           |
+
+        * Values buffer
+
+          | Bytes 0-3   | Bytes 4-7   | Bytes 8-11  | Bytes 12-63           |
+          |-------------|-------------|-------------|-----------------------|
+          | 1.0         | unspecified | 2.0         | unspecified (padding) |
+
+
 Buffer Listing for Each Layout
 ------------------------------
 
@@ -784,6 +870,7 @@ of memory buffers for each layout.
    "Dense Union",type ids,offsets,
    "Null",,,
    "Dictionary-encoded",validity,data (indices),
+   "Run-end encoded",,,
 
 Logical Types
 =============
diff --git a/format/Schema.fbs b/format/Schema.fbs
index 7ee827b5de8da..ce29c25b7d1c8 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -19,8 +19,9 @@
 
 /// Format Version History.
 /// Version 1.0 - Forward and backwards compatibility guaranteed.
-/// Version 1.1 - Add Decimal256 (No format release).
-/// Version 1.2 (Pending)- Add Interval MONTH_DAY_NANO
+/// Version 1.1 - Add Decimal256.
+/// Version 1.2 - Add Interval MONTH_DAY_NANO.
+/// Version 1.3 - Add Run-End Encoded.
 
 namespace org.apache.arrow.flatbuf;
 
@@ -178,6 +179,14 @@ table FixedSizeBinary {
 table Bool {
 }
 
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in 
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+table RunEndEncoded {
+}
+
 /// Exact decimal value represented as an integer value in two's
 /// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
 /// are used. The representation uses the endianness indicated
@@ -417,6 +426,7 @@ union Type {
   LargeBinary,
   LargeUtf8,
   LargeList,
+  RunEndEncoded,
 }
 
 /// ----------------------------------------------------------------------
diff --git a/go/arrow/internal/flatbuf/RunEndEncoded.go b/go/arrow/internal/flatbuf/RunEndEncoded.go
new file mode 100644
index 0000000000000..fa414c1bf0eed
--- /dev/null
+++ b/go/arrow/internal/flatbuf/RunEndEncoded.go
@@ -0,0 +1,55 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package flatbuf
+
+import (
+	flatbuffers "github.com/google/flatbuffers/go"
+)
+
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in 
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+type RunEndEncoded struct {
+	_tab flatbuffers.Table
+}
+
+func GetRootAsRunEndEncoded(buf []byte, offset flatbuffers.UOffsetT) *RunEndEncoded {
+	n := flatbuffers.GetUOffsetT(buf[offset:])
+	x := &RunEndEncoded{}
+	x.Init(buf, n+offset)
+	return x
+}
+
+func (rcv *RunEndEncoded) Init(buf []byte, i flatbuffers.UOffsetT) {
+	rcv._tab.Bytes = buf
+	rcv._tab.Pos = i
+}
+
+func (rcv *RunEndEncoded) Table() flatbuffers.Table {
+	return rcv._tab
+}
+
+func RunEndEncodedStart(builder *flatbuffers.Builder) {
+	builder.StartObject(0)
+}
+func RunEndEncodedEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+	return builder.EndObject()
+}
diff --git a/go/arrow/internal/flatbuf/Type.go b/go/arrow/internal/flatbuf/Type.go
index 319c6c6a4a5d6..707444b8e1ecd 100644
--- a/go/arrow/internal/flatbuf/Type.go
+++ b/go/arrow/internal/flatbuf/Type.go
@@ -48,6 +48,7 @@ const (
 	TypeLargeBinary     Type = 19
 	TypeLargeUtf8       Type = 20
 	TypeLargeList       Type = 21
+	TypeRunEndEncoded   Type = 22
 )
 
 var EnumNamesType = map[Type]string{
@@ -73,6 +74,7 @@ var EnumNamesType = map[Type]string{
 	TypeLargeBinary:     "LargeBinary",
 	TypeLargeUtf8:       "LargeUtf8",
 	TypeLargeList:       "LargeList",
+	TypeRunEndEncoded:   "RunEndEncoded",
 }
 
 var EnumValuesType = map[string]Type{
@@ -98,6 +100,7 @@ var EnumValuesType = map[string]Type{
 	"LargeBinary":     TypeLargeBinary,
 	"LargeUtf8":       TypeLargeUtf8,
 	"LargeList":       TypeLargeList,
+	"RunEndEncoded":   TypeRunEndEncoded,
 }
 
 func (v Type) String() string {