cpp/src/plasma/plasma_generated.h

// automatically generated by the FlatBuffers compiler, do not modify


#ifndef FLATBUFFERS_GENERATED_PLASMA_PLASMA_FLATBUF_H_
#define FLATBUFFERS_GENERATED_PLASMA_PLASMA_FLATBUF_H_

#include "flatbuffers/flatbuffers.h"

#include "common_generated.h"

namespace plasma {
namespace flatbuf {

struct PlasmaObjectSpec;

struct PlasmaSetOptionsRequest;
struct PlasmaSetOptionsRequestBuilder;
struct PlasmaSetOptionsRequestT;

struct PlasmaSetOptionsReply;
struct PlasmaSetOptionsReplyBuilder;
struct PlasmaSetOptionsReplyT;

struct PlasmaGetDebugStringRequest;
struct PlasmaGetDebugStringRequestBuilder;
struct PlasmaGetDebugStringRequestT;

struct PlasmaGetDebugStringReply;
struct PlasmaGetDebugStringReplyBuilder;
struct PlasmaGetDebugStringReplyT;

struct PlasmaCreateRequest;
struct PlasmaCreateRequestBuilder;
struct PlasmaCreateRequestT;

struct CudaHandle;
struct CudaHandleBuilder;
struct CudaHandleT;

struct PlasmaCreateReply;
struct PlasmaCreateReplyBuilder;
struct PlasmaCreateReplyT;

struct PlasmaCreateAndSealRequest;
struct PlasmaCreateAndSealRequestBuilder;
struct PlasmaCreateAndSealRequestT;

struct PlasmaCreateAndSealReply;
struct PlasmaCreateAndSealReplyBuilder;
struct PlasmaCreateAndSealReplyT;

struct PlasmaCreateAndSealBatchRequest;
struct PlasmaCreateAndSealBatchRequestBuilder;
struct PlasmaCreateAndSealBatchRequestT;

struct PlasmaCreateAndSealBatchReply;
struct PlasmaCreateAndSealBatchReplyBuilder;
struct PlasmaCreateAndSealBatchReplyT;

struct PlasmaAbortRequest;
struct PlasmaAbortRequestBuilder;
struct PlasmaAbortRequestT;

struct PlasmaAbortReply;
struct PlasmaAbortReplyBuilder;
struct PlasmaAbortReplyT;

struct PlasmaSealRequest;
struct PlasmaSealRequestBuilder;
struct PlasmaSealRequestT;

struct PlasmaSealReply;
struct PlasmaSealReplyBuilder;
struct PlasmaSealReplyT;

struct PlasmaGetRequest;
struct PlasmaGetRequestBuilder;
struct PlasmaGetRequestT;

struct PlasmaGetReply;
struct PlasmaGetReplyBuilder;
struct PlasmaGetReplyT;

struct PlasmaReleaseRequest;
struct PlasmaReleaseRequestBuilder;
struct PlasmaReleaseRequestT;

struct PlasmaReleaseReply;
struct PlasmaReleaseReplyBuilder;
struct PlasmaReleaseReplyT;

struct PlasmaDeleteRequest;
struct PlasmaDeleteRequestBuilder;
struct PlasmaDeleteRequestT;

struct PlasmaDeleteReply;
struct PlasmaDeleteReplyBuilder;
struct PlasmaDeleteReplyT;

struct PlasmaContainsRequest;
struct PlasmaContainsRequestBuilder;
struct PlasmaContainsRequestT;

struct PlasmaContainsReply;
struct PlasmaContainsReplyBuilder;
struct PlasmaContainsReplyT;

struct PlasmaListRequest;
struct PlasmaListRequestBuilder;
struct PlasmaListRequestT;

struct PlasmaListReply;
struct PlasmaListReplyBuilder;
struct PlasmaListReplyT;

struct PlasmaConnectRequest;
struct PlasmaConnectRequestBuilder;
struct PlasmaConnectRequestT;

struct PlasmaConnectReply;
struct PlasmaConnectReplyBuilder;
struct PlasmaConnectReplyT;

struct PlasmaEvictRequest;
struct PlasmaEvictRequestBuilder;
struct PlasmaEvictRequestT;

struct PlasmaEvictReply;
struct PlasmaEvictReplyBuilder;
struct PlasmaEvictReplyT;

struct PlasmaSubscribeRequest;
struct PlasmaSubscribeRequestBuilder;
struct PlasmaSubscribeRequestT;

struct PlasmaNotification;
struct PlasmaNotificationBuilder;
struct PlasmaNotificationT;

struct PlasmaDataRequest;
struct PlasmaDataRequestBuilder;
struct PlasmaDataRequestT;

struct PlasmaDataReply;
struct PlasmaDataReplyBuilder;
struct PlasmaDataReplyT;

struct PlasmaRefreshLRURequest;
struct PlasmaRefreshLRURequestBuilder;
struct PlasmaRefreshLRURequestT;

struct PlasmaRefreshLRUReply;
struct PlasmaRefreshLRUReplyBuilder;
struct PlasmaRefreshLRUReplyT;

enum class MessageType : int64_t {
  PlasmaDisconnectClient = 0,
  PlasmaCreateRequest = 1LL,
  PlasmaCreateReply = 2LL,
  PlasmaCreateAndSealRequest = 3LL,
  PlasmaCreateAndSealReply = 4LL,
  PlasmaAbortRequest = 5LL,
  PlasmaAbortReply = 6LL,
  PlasmaSealRequest = 7LL,
  PlasmaSealReply = 8LL,
  PlasmaGetRequest = 9LL,
  PlasmaGetReply = 10LL,
  PlasmaReleaseRequest = 11LL,
  PlasmaReleaseReply = 12LL,
  PlasmaDeleteRequest = 13LL,
  PlasmaDeleteReply = 14LL,
  PlasmaContainsRequest = 15LL,
  PlasmaContainsReply = 16LL,
  PlasmaListRequest = 17LL,
  PlasmaListReply = 18LL,
  PlasmaConnectRequest = 19LL,
  PlasmaConnectReply = 20LL,
  PlasmaEvictRequest = 21LL,
  PlasmaEvictReply = 22LL,
  PlasmaSubscribeRequest = 23LL,
  PlasmaUnsubscribeRequest = 24LL,
  PlasmaDataRequest = 25LL,
  PlasmaDataReply = 26LL,
  PlasmaNotification = 27LL,
  PlasmaSetOptionsRequest = 28LL,
  PlasmaSetOptionsReply = 29LL,
  PlasmaGetDebugStringRequest = 30LL,
  PlasmaGetDebugStringReply = 31LL,
  PlasmaCreateAndSealBatchRequest = 32LL,
  PlasmaCreateAndSealBatchReply = 33LL,
  PlasmaRefreshLRURequest = 34LL,
  PlasmaRefreshLRUReply = 35LL,
  MIN = PlasmaDisconnectClient,
  MAX = PlasmaRefreshLRUReply
};

inline const MessageType (&EnumValuesMessageType())[36] {
  static const MessageType values[] = {
    MessageType::PlasmaDisconnectClient,
    MessageType::PlasmaCreateRequest,
    MessageType::PlasmaCreateReply,
    MessageType::PlasmaCreateAndSealRequest,
    MessageType::PlasmaCreateAndSealReply,
    MessageType::PlasmaAbortRequest,
    MessageType::PlasmaAbortReply,
    MessageType::PlasmaSealRequest,
    MessageType::PlasmaSealReply,
    MessageType::PlasmaGetRequest,
    MessageType::PlasmaGetReply,
    MessageType::PlasmaReleaseRequest,
    MessageType::PlasmaReleaseReply,
    MessageType::PlasmaDeleteRequest,
    MessageType::PlasmaDeleteReply,
    MessageType::PlasmaContainsRequest,
    MessageType::PlasmaContainsReply,
    MessageType::PlasmaListRequest,
    MessageType::PlasmaListReply,
    MessageType::PlasmaConnectRequest,
    MessageType::PlasmaConnectReply,
    MessageType::PlasmaEvictRequest,
    MessageType::PlasmaEvictReply,
    MessageType::PlasmaSubscribeRequest,
    MessageType::PlasmaUnsubscribeRequest,
    MessageType::PlasmaDataRequest,
    MessageType::PlasmaDataReply,
    MessageType::PlasmaNotification,
    MessageType::PlasmaSetOptionsRequest,
    MessageType::PlasmaSetOptionsReply,
    MessageType::PlasmaGetDebugStringRequest,
    MessageType::PlasmaGetDebugStringReply,
    MessageType::PlasmaCreateAndSealBatchRequest,
    MessageType::PlasmaCreateAndSealBatchReply,
    MessageType::PlasmaRefreshLRURequest,
    MessageType::PlasmaRefreshLRUReply
  };
  return values;
}

inline const char * const *EnumNamesMessageType() {
  static const char * const names[37] = {
    "PlasmaDisconnectClient",
    "PlasmaCreateRequest",
    "PlasmaCreateReply",
    "PlasmaCreateAndSealRequest",
    "PlasmaCreateAndSealReply",
    "PlasmaAbortRequest",
    "PlasmaAbortReply",
    "PlasmaSealRequest",
    "PlasmaSealReply",
    "PlasmaGetRequest",
    "PlasmaGetReply",
    "PlasmaReleaseRequest",
    "PlasmaReleaseReply",
    "PlasmaDeleteRequest",
    "PlasmaDeleteReply",
    "PlasmaContainsRequest",
    "PlasmaContainsReply",
    "PlasmaListRequest",
    "PlasmaListReply",
    "PlasmaConnectRequest",
    "PlasmaConnectReply",
    "PlasmaEvictRequest",
    "PlasmaEvictReply",
    "PlasmaSubscribeRequest",
    "PlasmaUnsubscribeRequest",
    "PlasmaDataRequest",
    "PlasmaDataReply",
    "PlasmaNotification",
    "PlasmaSetOptionsRequest",
    "PlasmaSetOptionsReply",
    "PlasmaGetDebugStringRequest",
    "PlasmaGetDebugStringReply",
    "PlasmaCreateAndSealBatchRequest",
    "PlasmaCreateAndSealBatchReply",
    "PlasmaRefreshLRURequest",
    "PlasmaRefreshLRUReply",
    nullptr
  };
  return names;
}

inline const char *EnumNameMessageType(MessageType e) {
  if (flatbuffers::IsOutRange(e, MessageType::PlasmaDisconnectClient, MessageType::PlasmaRefreshLRUReply)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMessageType()[index];
}

enum class PlasmaError : int32_t {
  OK = 0,
  ObjectExists = 1,
  ObjectNotFound = 2,
  OutOfMemory = 3,
  ObjectNotSealed = 4,
  ObjectInUse = 5,
  MIN = OK,
  MAX = ObjectInUse
};

inline const PlasmaError (&EnumValuesPlasmaError())[6] {
  static const PlasmaError values[] = {
    PlasmaError::OK,
    PlasmaError::ObjectExists,
    PlasmaError::ObjectNotFound,
    PlasmaError::OutOfMemory,
    PlasmaError::ObjectNotSealed,
    PlasmaError::ObjectInUse
  };
  return values;
}

inline const char * const *EnumNamesPlasmaError() {
  static const char * const names[7] = {
    "OK",
    "ObjectExists",
    "ObjectNotFound",
    "OutOfMemory",
    "ObjectNotSealed",
    "ObjectInUse",
    nullptr
  };
  return names;
}

inline const char *EnumNamePlasmaError(PlasmaError e) {
  if (flatbuffers::IsOutRange(e, PlasmaError::OK, PlasmaError::ObjectInUse)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesPlasmaError()[index];
}

FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) PlasmaObjectSpec FLATBUFFERS_FINAL_CLASS {
 private:
  int32_t segment_index_;
  int32_t padding0__;
  uint64_t data_offset_;
  uint64_t data_size_;
  uint64_t metadata_offset_;
  uint64_t metadata_size_;
  int32_t device_num_;
  int32_t padding1__;

 public:
  PlasmaObjectSpec() {
    memset(static_cast<void *>(this), 0, sizeof(PlasmaObjectSpec));
  }
  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)),
        padding0__(0),
        data_offset_(flatbuffers::EndianScalar(_data_offset)),
        data_size_(flatbuffers::EndianScalar(_data_size)),
        metadata_offset_(flatbuffers::EndianScalar(_metadata_offset)),
        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_);
  }
  uint64_t data_offset() const {
    return flatbuffers::EndianScalar(data_offset_);
  }
  uint64_t data_size() const {
    return flatbuffers::EndianScalar(data_size_);
  }
  uint64_t metadata_offset() const {
    return flatbuffers::EndianScalar(metadata_offset_);
  }
  uint64_t metadata_size() const {
    return flatbuffers::EndianScalar(metadata_size_);
  }
  int32_t device_num() const {
    return flatbuffers::EndianScalar(device_num_);
  }
};
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) {
  }
};

struct PlasmaSetOptionsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaSetOptionsRequestT NativeTableType;
  typedef PlasmaSetOptionsRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CLIENT_NAME = 4,
    VT_OUTPUT_MEMORY_QUOTA = 6
  };
  const flatbuffers::String *client_name() const {
    return GetPointer<const flatbuffers::String *>(VT_CLIENT_NAME);
  }
  int64_t output_memory_quota() const {
    return GetField<int64_t>(VT_OUTPUT_MEMORY_QUOTA, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CLIENT_NAME) &&
           verifier.VerifyString(client_name()) &&
           VerifyField<int64_t>(verifier, VT_OUTPUT_MEMORY_QUOTA) &&
           verifier.EndTable();
  }
  PlasmaSetOptionsRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaSetOptionsRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaSetOptionsRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaSetOptionsRequestBuilder {
  typedef PlasmaSetOptionsRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_client_name(flatbuffers::Offset<flatbuffers::String> client_name) {
    fbb_.AddOffset(PlasmaSetOptionsRequest::VT_CLIENT_NAME, client_name);
  }
  void add_output_memory_quota(int64_t output_memory_quota) {
    fbb_.AddElement<int64_t>(PlasmaSetOptionsRequest::VT_OUTPUT_MEMORY_QUOTA, output_memory_quota, 0);
  }
  explicit PlasmaSetOptionsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> client_name = 0,
    int64_t output_memory_quota = 0) {
  PlasmaSetOptionsRequestBuilder builder_(_fbb);
  builder_.add_output_memory_quota(output_memory_quota);
  builder_.add_client_name(client_name);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *client_name = nullptr,
    int64_t output_memory_quota = 0) {
  auto client_name__ = client_name ? _fbb.CreateString(client_name) : 0;
  return plasma::flatbuf::CreatePlasmaSetOptionsRequest(
      _fbb,
      client_name__,
      output_memory_quota);
}

flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaSetOptionsReplyT : public flatbuffers::NativeTable {
  typedef PlasmaSetOptionsReply TableType;
  plasma::flatbuf::PlasmaError error;
  PlasmaSetOptionsReplyT()
      : error(plasma::flatbuf::PlasmaError::OK) {
  }
};

struct PlasmaSetOptionsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaSetOptionsReplyT NativeTableType;
  typedef PlasmaSetOptionsReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ERROR = 4
  };
  plasma::flatbuf::PlasmaError error() const {
    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           verifier.EndTable();
  }
  PlasmaSetOptionsReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaSetOptionsReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaSetOptionsReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaSetOptionsReplyBuilder {
  typedef PlasmaSetOptionsReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_error(plasma::flatbuf::PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaSetOptionsReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  explicit PlasmaSetOptionsReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  PlasmaSetOptionsReplyBuilder builder_(_fbb);
  builder_.add_error(error);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaGetDebugStringRequestT : public flatbuffers::NativeTable {
  typedef PlasmaGetDebugStringRequest TableType;
  PlasmaGetDebugStringRequestT() {
  }
};

struct PlasmaGetDebugStringRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaGetDebugStringRequestT NativeTableType;
  typedef PlasmaGetDebugStringRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  PlasmaGetDebugStringRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaGetDebugStringRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaGetDebugStringRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaGetDebugStringRequestBuilder {
  typedef PlasmaGetDebugStringRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit PlasmaGetDebugStringRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  PlasmaGetDebugStringRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaGetDebugStringReplyT : public flatbuffers::NativeTable {
  typedef PlasmaGetDebugStringReply TableType;
  std::string debug_string;
  PlasmaGetDebugStringReplyT() {
  }
};

struct PlasmaGetDebugStringReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaGetDebugStringReplyT NativeTableType;
  typedef PlasmaGetDebugStringReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DEBUG_STRING = 4
  };
  const flatbuffers::String *debug_string() const {
    return GetPointer<const flatbuffers::String *>(VT_DEBUG_STRING);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DEBUG_STRING) &&
           verifier.VerifyString(debug_string()) &&
           verifier.EndTable();
  }
  PlasmaGetDebugStringReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaGetDebugStringReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaGetDebugStringReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaGetDebugStringReplyBuilder {
  typedef PlasmaGetDebugStringReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_debug_string(flatbuffers::Offset<flatbuffers::String> debug_string) {
    fbb_.AddOffset(PlasmaGetDebugStringReply::VT_DEBUG_STRING, debug_string);
  }
  explicit PlasmaGetDebugStringReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> debug_string = 0) {
  PlasmaGetDebugStringReplyBuilder builder_(_fbb);
  builder_.add_debug_string(debug_string);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *debug_string = nullptr) {
  auto debug_string__ = debug_string ? _fbb.CreateString(debug_string) : 0;
  return plasma::flatbuf::CreatePlasmaGetDebugStringReply(
      _fbb,
      debug_string__);
}

flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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) {
  }
};

struct PlasmaCreateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateRequestT NativeTableType;
  typedef PlasmaCreateRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_EVICT_IF_FULL = 6,
    VT_DATA_SIZE = 8,
    VT_METADATA_SIZE = 10,
    VT_DEVICE_NUM = 12
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  bool evict_if_full() const {
    return GetField<uint8_t>(VT_EVICT_IF_FULL, 0) != 0;
  }
  uint64_t data_size() const {
    return GetField<uint64_t>(VT_DATA_SIZE, 0);
  }
  uint64_t metadata_size() const {
    return GetField<uint64_t>(VT_METADATA_SIZE, 0);
  }
  int32_t device_num() const {
    return GetField<int32_t>(VT_DEVICE_NUM, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<uint8_t>(verifier, VT_EVICT_IF_FULL) &&
           VerifyField<uint64_t>(verifier, VT_DATA_SIZE) &&
           VerifyField<uint64_t>(verifier, VT_METADATA_SIZE) &&
           VerifyField<int32_t>(verifier, VT_DEVICE_NUM) &&
           verifier.EndTable();
  }
  PlasmaCreateRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaCreateRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaCreateRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaCreateRequestBuilder {
  typedef PlasmaCreateRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaCreateRequest::VT_OBJECT_ID, object_id);
  }
  void add_evict_if_full(bool evict_if_full) {
    fbb_.AddElement<uint8_t>(PlasmaCreateRequest::VT_EVICT_IF_FULL, static_cast<uint8_t>(evict_if_full), 0);
  }
  void add_data_size(uint64_t data_size) {
    fbb_.AddElement<uint64_t>(PlasmaCreateRequest::VT_DATA_SIZE, data_size, 0);
  }
  void add_metadata_size(uint64_t metadata_size) {
    fbb_.AddElement<uint64_t>(PlasmaCreateRequest::VT_METADATA_SIZE, metadata_size, 0);
  }
  void add_device_num(int32_t device_num) {
    fbb_.AddElement<int32_t>(PlasmaCreateRequest::VT_DEVICE_NUM, device_num, 0);
  }
  explicit PlasmaCreateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    bool evict_if_full = false,
    uint64_t data_size = 0,
    uint64_t metadata_size = 0,
    int32_t device_num = 0) {
  PlasmaCreateRequestBuilder builder_(_fbb);
  builder_.add_metadata_size(metadata_size);
  builder_.add_data_size(data_size);
  builder_.add_device_num(device_num);
  builder_.add_object_id(object_id);
  builder_.add_evict_if_full(evict_if_full);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    bool evict_if_full = false,
    uint64_t data_size = 0,
    uint64_t metadata_size = 0,
    int32_t device_num = 0) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaCreateRequest(
      _fbb,
      object_id__,
      evict_if_full,
      data_size,
      metadata_size,
      device_num);
}

flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct CudaHandleT : public flatbuffers::NativeTable {
  typedef CudaHandle TableType;
  std::vector<uint8_t> handle;
  CudaHandleT() {
  }
};

struct CudaHandle FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef CudaHandleT NativeTableType;
  typedef CudaHandleBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_HANDLE = 4
  };
  const flatbuffers::Vector<uint8_t> *handle() const {
    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_HANDLE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_HANDLE) &&
           verifier.VerifyVector(handle()) &&
           verifier.EndTable();
  }
  CudaHandleT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(CudaHandleT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<CudaHandle> Pack(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct CudaHandleBuilder {
  typedef CudaHandle Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_handle(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> handle) {
    fbb_.AddOffset(CudaHandle::VT_HANDLE, handle);
  }
  explicit CudaHandleBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<CudaHandle> CreateCudaHandle(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> handle = 0) {
  CudaHandleBuilder builder_(_fbb);
  builder_.add_handle(handle);
  return builder_.Finish();
}

inline flatbuffers::Offset<CudaHandle> CreateCudaHandleDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<uint8_t> *handle = nullptr) {
  auto handle__ = handle ? _fbb.CreateVector<uint8_t>(*handle) : 0;
  return plasma::flatbuf::CreateCudaHandle(
      _fbb,
      handle__);
}

flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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) {
  }
};

struct PlasmaCreateReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateReplyT NativeTableType;
  typedef PlasmaCreateReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_PLASMA_OBJECT = 6,
    VT_ERROR = 8,
    VT_STORE_FD = 10,
    VT_MMAP_SIZE = 12,
    VT_IPC_HANDLE = 14
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  const plasma::flatbuf::PlasmaObjectSpec *plasma_object() const {
    return GetStruct<const plasma::flatbuf::PlasmaObjectSpec *>(VT_PLASMA_OBJECT);
  }
  plasma::flatbuf::PlasmaError error() const {
    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  int32_t store_fd() const {
    return GetField<int32_t>(VT_STORE_FD, 0);
  }
  int64_t mmap_size() const {
    return GetField<int64_t>(VT_MMAP_SIZE, 0);
  }
  const plasma::flatbuf::CudaHandle *ipc_handle() const {
    return GetPointer<const plasma::flatbuf::CudaHandle *>(VT_IPC_HANDLE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<plasma::flatbuf::PlasmaObjectSpec>(verifier, VT_PLASMA_OBJECT) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           VerifyField<int32_t>(verifier, VT_STORE_FD) &&
           VerifyField<int64_t>(verifier, VT_MMAP_SIZE) &&
           VerifyOffset(verifier, VT_IPC_HANDLE) &&
           verifier.VerifyTable(ipc_handle()) &&
           verifier.EndTable();
  }
  PlasmaCreateReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaCreateReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaCreateReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaCreateReplyBuilder {
  typedef PlasmaCreateReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaCreateReply::VT_OBJECT_ID, object_id);
  }
  void add_plasma_object(const plasma::flatbuf::PlasmaObjectSpec *plasma_object) {
    fbb_.AddStruct(PlasmaCreateReply::VT_PLASMA_OBJECT, plasma_object);
  }
  void add_error(plasma::flatbuf::PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaCreateReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  void add_store_fd(int32_t store_fd) {
    fbb_.AddElement<int32_t>(PlasmaCreateReply::VT_STORE_FD, store_fd, 0);
  }
  void add_mmap_size(int64_t mmap_size) {
    fbb_.AddElement<int64_t>(PlasmaCreateReply::VT_MMAP_SIZE, mmap_size, 0);
  }
  void add_ipc_handle(flatbuffers::Offset<plasma::flatbuf::CudaHandle> ipc_handle) {
    fbb_.AddOffset(PlasmaCreateReply::VT_IPC_HANDLE, ipc_handle);
  }
  explicit PlasmaCreateReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    const plasma::flatbuf::PlasmaObjectSpec *plasma_object = 0,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK,
    int32_t store_fd = 0,
    int64_t mmap_size = 0,
    flatbuffers::Offset<plasma::flatbuf::CudaHandle> ipc_handle = 0) {
  PlasmaCreateReplyBuilder builder_(_fbb);
  builder_.add_mmap_size(mmap_size);
  builder_.add_ipc_handle(ipc_handle);
  builder_.add_store_fd(store_fd);
  builder_.add_error(error);
  builder_.add_plasma_object(plasma_object);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    const plasma::flatbuf::PlasmaObjectSpec *plasma_object = 0,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK,
    int32_t store_fd = 0,
    int64_t mmap_size = 0,
    flatbuffers::Offset<plasma::flatbuf::CudaHandle> ipc_handle = 0) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaCreateReply(
      _fbb,
      object_id__,
      plasma_object,
      error,
      store_fd,
      mmap_size,
      ipc_handle);
}

flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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) {
  }
};

struct PlasmaCreateAndSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateAndSealRequestT NativeTableType;
  typedef PlasmaCreateAndSealRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_EVICT_IF_FULL = 6,
    VT_DATA = 8,
    VT_METADATA = 10,
    VT_DIGEST = 12
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  bool evict_if_full() const {
    return GetField<uint8_t>(VT_EVICT_IF_FULL, 0) != 0;
  }
  const flatbuffers::String *data() const {
    return GetPointer<const flatbuffers::String *>(VT_DATA);
  }
  const flatbuffers::String *metadata() const {
    return GetPointer<const flatbuffers::String *>(VT_METADATA);
  }
  const flatbuffers::String *digest() const {
    return GetPointer<const flatbuffers::String *>(VT_DIGEST);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<uint8_t>(verifier, VT_EVICT_IF_FULL) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyString(data()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyString(metadata()) &&
           VerifyOffset(verifier, VT_DIGEST) &&
           verifier.VerifyString(digest()) &&
           verifier.EndTable();
  }
  PlasmaCreateAndSealRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaCreateAndSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaCreateAndSealRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaCreateAndSealRequestBuilder {
  typedef PlasmaCreateAndSealRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_OBJECT_ID, object_id);
  }
  void add_evict_if_full(bool evict_if_full) {
    fbb_.AddElement<uint8_t>(PlasmaCreateAndSealRequest::VT_EVICT_IF_FULL, static_cast<uint8_t>(evict_if_full), 0);
  }
  void add_data(flatbuffers::Offset<flatbuffers::String> data) {
    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_DATA, data);
  }
  void add_metadata(flatbuffers::Offset<flatbuffers::String> metadata) {
    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_METADATA, metadata);
  }
  void add_digest(flatbuffers::Offset<flatbuffers::String> digest) {
    fbb_.AddOffset(PlasmaCreateAndSealRequest::VT_DIGEST, digest);
  }
  explicit PlasmaCreateAndSealRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    bool evict_if_full = false,
    flatbuffers::Offset<flatbuffers::String> data = 0,
    flatbuffers::Offset<flatbuffers::String> metadata = 0,
    flatbuffers::Offset<flatbuffers::String> digest = 0) {
  PlasmaCreateAndSealRequestBuilder builder_(_fbb);
  builder_.add_digest(digest);
  builder_.add_metadata(metadata);
  builder_.add_data(data);
  builder_.add_object_id(object_id);
  builder_.add_evict_if_full(evict_if_full);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    bool evict_if_full = false,
    const char *data = nullptr,
    const char *metadata = nullptr,
    const char *digest = nullptr) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  auto data__ = data ? _fbb.CreateString(data) : 0;
  auto metadata__ = metadata ? _fbb.CreateString(metadata) : 0;
  auto digest__ = digest ? _fbb.CreateString(digest) : 0;
  return plasma::flatbuf::CreatePlasmaCreateAndSealRequest(
      _fbb,
      object_id__,
      evict_if_full,
      data__,
      metadata__,
      digest__);
}

flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaCreateAndSealReplyT : public flatbuffers::NativeTable {
  typedef PlasmaCreateAndSealReply TableType;
  plasma::flatbuf::PlasmaError error;
  PlasmaCreateAndSealReplyT()
      : error(plasma::flatbuf::PlasmaError::OK) {
  }
};

struct PlasmaCreateAndSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateAndSealReplyT NativeTableType;
  typedef PlasmaCreateAndSealReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ERROR = 4
  };
  plasma::flatbuf::PlasmaError error() const {
    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           verifier.EndTable();
  }
  PlasmaCreateAndSealReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaCreateAndSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaCreateAndSealReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaCreateAndSealReplyBuilder {
  typedef PlasmaCreateAndSealReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_error(plasma::flatbuf::PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaCreateAndSealReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  explicit PlasmaCreateAndSealReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  PlasmaCreateAndSealReplyBuilder builder_(_fbb);
  builder_.add_error(error);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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) {
  }
};

struct PlasmaCreateAndSealBatchRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateAndSealBatchRequestT NativeTableType;
  typedef PlasmaCreateAndSealBatchRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_IDS = 4,
    VT_EVICT_IF_FULL = 6,
    VT_DATA = 8,
    VT_METADATA = 10,
    VT_DIGEST = 12
  };
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
  }
  bool evict_if_full() const {
    return GetField<uint8_t>(VT_EVICT_IF_FULL, 0) != 0;
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *data() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DATA);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *metadata() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_METADATA);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *digest() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_DIGEST);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.VerifyVector(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           VerifyField<uint8_t>(verifier, VT_EVICT_IF_FULL) &&
           VerifyOffset(verifier, VT_DATA) &&
           verifier.VerifyVector(data()) &&
           verifier.VerifyVectorOfStrings(data()) &&
           VerifyOffset(verifier, VT_METADATA) &&
           verifier.VerifyVector(metadata()) &&
           verifier.VerifyVectorOfStrings(metadata()) &&
           VerifyOffset(verifier, VT_DIGEST) &&
           verifier.VerifyVector(digest()) &&
           verifier.VerifyVectorOfStrings(digest()) &&
           verifier.EndTable();
  }
  PlasmaCreateAndSealBatchRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaCreateAndSealBatchRequestBuilder {
  typedef PlasmaCreateAndSealBatchRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_OBJECT_IDS, object_ids);
  }
  void add_evict_if_full(bool evict_if_full) {
    fbb_.AddElement<uint8_t>(PlasmaCreateAndSealBatchRequest::VT_EVICT_IF_FULL, static_cast<uint8_t>(evict_if_full), 0);
  }
  void add_data(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> data) {
    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_DATA, data);
  }
  void add_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> metadata) {
    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_METADATA, metadata);
  }
  void add_digest(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> digest) {
    fbb_.AddOffset(PlasmaCreateAndSealBatchRequest::VT_DIGEST, digest);
  }
  explicit PlasmaCreateAndSealBatchRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
    bool evict_if_full = false,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> data = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> metadata = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> digest = 0) {
  PlasmaCreateAndSealBatchRequestBuilder builder_(_fbb);
  builder_.add_digest(digest);
  builder_.add_metadata(metadata);
  builder_.add_data(data);
  builder_.add_object_ids(object_ids);
  builder_.add_evict_if_full(evict_if_full);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
    bool evict_if_full = false,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *data = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *metadata = nullptr,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *digest = nullptr) {
  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
  auto data__ = data ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*data) : 0;
  auto metadata__ = metadata ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*metadata) : 0;
  auto digest__ = digest ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*digest) : 0;
  return plasma::flatbuf::CreatePlasmaCreateAndSealBatchRequest(
      _fbb,
      object_ids__,
      evict_if_full,
      data__,
      metadata__,
      digest__);
}

flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaCreateAndSealBatchReplyT : public flatbuffers::NativeTable {
  typedef PlasmaCreateAndSealBatchReply TableType;
  plasma::flatbuf::PlasmaError error;
  PlasmaCreateAndSealBatchReplyT()
      : error(plasma::flatbuf::PlasmaError::OK) {
  }
};

struct PlasmaCreateAndSealBatchReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateAndSealBatchReplyT NativeTableType;
  typedef PlasmaCreateAndSealBatchReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ERROR = 4
  };
  plasma::flatbuf::PlasmaError error() const {
    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           verifier.EndTable();
  }
  PlasmaCreateAndSealBatchReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaCreateAndSealBatchReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaCreateAndSealBatchReplyBuilder {
  typedef PlasmaCreateAndSealBatchReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_error(plasma::flatbuf::PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaCreateAndSealBatchReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  explicit PlasmaCreateAndSealBatchReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatchReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  PlasmaCreateAndSealBatchReplyBuilder builder_(_fbb);
  builder_.add_error(error);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatchReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaAbortRequestT : public flatbuffers::NativeTable {
  typedef PlasmaAbortRequest TableType;
  std::string object_id;
  PlasmaAbortRequestT() {
  }
};

struct PlasmaAbortRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaAbortRequestT NativeTableType;
  typedef PlasmaAbortRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           verifier.EndTable();
  }
  PlasmaAbortRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaAbortRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaAbortRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaAbortRequestBuilder {
  typedef PlasmaAbortRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaAbortRequest::VT_OBJECT_ID, object_id);
  }
  explicit PlasmaAbortRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
  PlasmaAbortRequestBuilder builder_(_fbb);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaAbortRequest(
      _fbb,
      object_id__);
}

flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaAbortReplyT : public flatbuffers::NativeTable {
  typedef PlasmaAbortReply TableType;
  std::string object_id;
  PlasmaAbortReplyT() {
  }
};

struct PlasmaAbortReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaAbortReplyT NativeTableType;
  typedef PlasmaAbortReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           verifier.EndTable();
  }
  PlasmaAbortReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaAbortReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaAbortReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaAbortReplyBuilder {
  typedef PlasmaAbortReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaAbortReply::VT_OBJECT_ID, object_id);
  }
  explicit PlasmaAbortReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
  PlasmaAbortReplyBuilder builder_(_fbb);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaAbortReply(
      _fbb,
      object_id__);
}

flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaSealRequestT : public flatbuffers::NativeTable {
  typedef PlasmaSealRequest TableType;
  std::string object_id;
  std::string digest;
  PlasmaSealRequestT() {
  }
};

struct PlasmaSealRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaSealRequestT NativeTableType;
  typedef PlasmaSealRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_DIGEST = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  const flatbuffers::String *digest() const {
    return GetPointer<const flatbuffers::String *>(VT_DIGEST);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyOffset(verifier, VT_DIGEST) &&
           verifier.VerifyString(digest()) &&
           verifier.EndTable();
  }
  PlasmaSealRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaSealRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaSealRequestBuilder {
  typedef PlasmaSealRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaSealRequest::VT_OBJECT_ID, object_id);
  }
  void add_digest(flatbuffers::Offset<flatbuffers::String> digest) {
    fbb_.AddOffset(PlasmaSealRequest::VT_DIGEST, digest);
  }
  explicit PlasmaSealRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    flatbuffers::Offset<flatbuffers::String> digest = 0) {
  PlasmaSealRequestBuilder builder_(_fbb);
  builder_.add_digest(digest);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    const char *digest = nullptr) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  auto digest__ = digest ? _fbb.CreateString(digest) : 0;
  return plasma::flatbuf::CreatePlasmaSealRequest(
      _fbb,
      object_id__,
      digest__);
}

flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaSealReplyT : public flatbuffers::NativeTable {
  typedef PlasmaSealReply TableType;
  std::string object_id;
  plasma::flatbuf::PlasmaError error;
  PlasmaSealReplyT()
      : error(plasma::flatbuf::PlasmaError::OK) {
  }
};

struct PlasmaSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaSealReplyT NativeTableType;
  typedef PlasmaSealReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_ERROR = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  plasma::flatbuf::PlasmaError error() const {
    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           verifier.EndTable();
  }
  PlasmaSealReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaSealReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaSealReplyBuilder {
  typedef PlasmaSealReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaSealReply::VT_OBJECT_ID, object_id);
  }
  void add_error(plasma::flatbuf::PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaSealReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  explicit PlasmaSealReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  PlasmaSealReplyBuilder builder_(_fbb);
  builder_.add_error(error);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaSealReply(
      _fbb,
      object_id__,
      error);
}

flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaGetRequestT : public flatbuffers::NativeTable {
  typedef PlasmaGetRequest TableType;
  std::vector<std::string> object_ids;
  int64_t timeout_ms;
  PlasmaGetRequestT()
      : timeout_ms(0) {
  }
};

struct PlasmaGetRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaGetRequestT NativeTableType;
  typedef PlasmaGetRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_IDS = 4,
    VT_TIMEOUT_MS = 6
  };
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
  }
  int64_t timeout_ms() const {
    return GetField<int64_t>(VT_TIMEOUT_MS, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.VerifyVector(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           VerifyField<int64_t>(verifier, VT_TIMEOUT_MS) &&
           verifier.EndTable();
  }
  PlasmaGetRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaGetRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaGetRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaGetRequestBuilder {
  typedef PlasmaGetRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaGetRequest::VT_OBJECT_IDS, object_ids);
  }
  void add_timeout_ms(int64_t timeout_ms) {
    fbb_.AddElement<int64_t>(PlasmaGetRequest::VT_TIMEOUT_MS, timeout_ms, 0);
  }
  explicit PlasmaGetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
    int64_t timeout_ms = 0) {
  PlasmaGetRequestBuilder builder_(_fbb);
  builder_.add_timeout_ms(timeout_ms);
  builder_.add_object_ids(object_ids);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
    int64_t timeout_ms = 0) {
  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
  return plasma::flatbuf::CreatePlasmaGetRequest(
      _fbb,
      object_ids__,
      timeout_ms);
}

flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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() {
  }
};

struct PlasmaGetReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaGetReplyT NativeTableType;
  typedef PlasmaGetReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_IDS = 4,
    VT_PLASMA_OBJECTS = 6,
    VT_STORE_FDS = 8,
    VT_MMAP_SIZES = 10,
    VT_HANDLES = 12
  };
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
  }
  const flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *> *plasma_objects() const {
    return GetPointer<const flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *> *>(VT_PLASMA_OBJECTS);
  }
  const flatbuffers::Vector<int32_t> *store_fds() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STORE_FDS);
  }
  const flatbuffers::Vector<int64_t> *mmap_sizes() const {
    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_MMAP_SIZES);
  }
  const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> *handles() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> *>(VT_HANDLES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.VerifyVector(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           VerifyOffset(verifier, VT_PLASMA_OBJECTS) &&
           verifier.VerifyVector(plasma_objects()) &&
           VerifyOffset(verifier, VT_STORE_FDS) &&
           verifier.VerifyVector(store_fds()) &&
           VerifyOffset(verifier, VT_MMAP_SIZES) &&
           verifier.VerifyVector(mmap_sizes()) &&
           VerifyOffset(verifier, VT_HANDLES) &&
           verifier.VerifyVector(handles()) &&
           verifier.VerifyVectorOfTables(handles()) &&
           verifier.EndTable();
  }
  PlasmaGetReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaGetReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaGetReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaGetReplyBuilder {
  typedef PlasmaGetReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaGetReply::VT_OBJECT_IDS, object_ids);
  }
  void add_plasma_objects(flatbuffers::Offset<flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *>> plasma_objects) {
    fbb_.AddOffset(PlasmaGetReply::VT_PLASMA_OBJECTS, plasma_objects);
  }
  void add_store_fds(flatbuffers::Offset<flatbuffers::Vector<int32_t>> store_fds) {
    fbb_.AddOffset(PlasmaGetReply::VT_STORE_FDS, store_fds);
  }
  void add_mmap_sizes(flatbuffers::Offset<flatbuffers::Vector<int64_t>> mmap_sizes) {
    fbb_.AddOffset(PlasmaGetReply::VT_MMAP_SIZES, mmap_sizes);
  }
  void add_handles(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>>> handles) {
    fbb_.AddOffset(PlasmaGetReply::VT_HANDLES, handles);
  }
  explicit PlasmaGetReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
    flatbuffers::Offset<flatbuffers::Vector<const plasma::flatbuf::PlasmaObjectSpec *>> plasma_objects = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> store_fds = 0,
    flatbuffers::Offset<flatbuffers::Vector<int64_t>> mmap_sizes = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>>> handles = 0) {
  PlasmaGetReplyBuilder builder_(_fbb);
  builder_.add_handles(handles);
  builder_.add_mmap_sizes(mmap_sizes);
  builder_.add_store_fds(store_fds);
  builder_.add_plasma_objects(plasma_objects);
  builder_.add_object_ids(object_ids);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
    const std::vector<plasma::flatbuf::PlasmaObjectSpec> *plasma_objects = nullptr,
    const std::vector<int32_t> *store_fds = nullptr,
    const std::vector<int64_t> *mmap_sizes = nullptr,
    const std::vector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> *handles = nullptr) {
  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
  auto plasma_objects__ = plasma_objects ? _fbb.CreateVectorOfStructs<plasma::flatbuf::PlasmaObjectSpec>(*plasma_objects) : 0;
  auto store_fds__ = store_fds ? _fbb.CreateVector<int32_t>(*store_fds) : 0;
  auto mmap_sizes__ = mmap_sizes ? _fbb.CreateVector<int64_t>(*mmap_sizes) : 0;
  auto handles__ = handles ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>>(*handles) : 0;
  return plasma::flatbuf::CreatePlasmaGetReply(
      _fbb,
      object_ids__,
      plasma_objects__,
      store_fds__,
      mmap_sizes__,
      handles__);
}

flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaReleaseRequestT : public flatbuffers::NativeTable {
  typedef PlasmaReleaseRequest TableType;
  std::string object_id;
  PlasmaReleaseRequestT() {
  }
};

struct PlasmaReleaseRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaReleaseRequestT NativeTableType;
  typedef PlasmaReleaseRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           verifier.EndTable();
  }
  PlasmaReleaseRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaReleaseRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaReleaseRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaReleaseRequestBuilder {
  typedef PlasmaReleaseRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaReleaseRequest::VT_OBJECT_ID, object_id);
  }
  explicit PlasmaReleaseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
  PlasmaReleaseRequestBuilder builder_(_fbb);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaReleaseRequest(
      _fbb,
      object_id__);
}

flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaReleaseReplyT : public flatbuffers::NativeTable {
  typedef PlasmaReleaseReply TableType;
  std::string object_id;
  plasma::flatbuf::PlasmaError error;
  PlasmaReleaseReplyT()
      : error(plasma::flatbuf::PlasmaError::OK) {
  }
};

struct PlasmaReleaseReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaReleaseReplyT NativeTableType;
  typedef PlasmaReleaseReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_ERROR = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  plasma::flatbuf::PlasmaError error() const {
    return static_cast<plasma::flatbuf::PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           verifier.EndTable();
  }
  PlasmaReleaseReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaReleaseReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaReleaseReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaReleaseReplyBuilder {
  typedef PlasmaReleaseReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaReleaseReply::VT_OBJECT_ID, object_id);
  }
  void add_error(plasma::flatbuf::PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaReleaseReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  explicit PlasmaReleaseReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  PlasmaReleaseReplyBuilder builder_(_fbb);
  builder_.add_error(error);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    plasma::flatbuf::PlasmaError error = plasma::flatbuf::PlasmaError::OK) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaReleaseReply(
      _fbb,
      object_id__,
      error);
}

flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaDeleteRequestT : public flatbuffers::NativeTable {
  typedef PlasmaDeleteRequest TableType;
  int32_t count;
  std::vector<std::string> object_ids;
  PlasmaDeleteRequestT()
      : count(0) {
  }
};

struct PlasmaDeleteRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaDeleteRequestT NativeTableType;
  typedef PlasmaDeleteRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COUNT = 4,
    VT_OBJECT_IDS = 6
  };
  int32_t count() const {
    return GetField<int32_t>(VT_COUNT, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_COUNT) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.VerifyVector(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           verifier.EndTable();
  }
  PlasmaDeleteRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaDeleteRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaDeleteRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaDeleteRequestBuilder {
  typedef PlasmaDeleteRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_count(int32_t count) {
    fbb_.AddElement<int32_t>(PlasmaDeleteRequest::VT_COUNT, count, 0);
  }
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaDeleteRequest::VT_OBJECT_IDS, object_ids);
  }
  explicit PlasmaDeleteRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t count = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0) {
  PlasmaDeleteRequestBuilder builder_(_fbb);
  builder_.add_object_ids(object_ids);
  builder_.add_count(count);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t count = 0,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr) {
  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
  return plasma::flatbuf::CreatePlasmaDeleteRequest(
      _fbb,
      count,
      object_ids__);
}

flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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) {
  }
};

struct PlasmaDeleteReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaDeleteReplyT NativeTableType;
  typedef PlasmaDeleteReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_COUNT = 4,
    VT_OBJECT_IDS = 6,
    VT_ERRORS = 8
  };
  int32_t count() const {
    return GetField<int32_t>(VT_COUNT, 0);
  }
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
  }
  const flatbuffers::Vector<int32_t> *errors() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_ERRORS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_COUNT) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.VerifyVector(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           VerifyOffset(verifier, VT_ERRORS) &&
           verifier.VerifyVector(errors()) &&
           verifier.EndTable();
  }
  PlasmaDeleteReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaDeleteReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaDeleteReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaDeleteReplyBuilder {
  typedef PlasmaDeleteReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_count(int32_t count) {
    fbb_.AddElement<int32_t>(PlasmaDeleteReply::VT_COUNT, count, 0);
  }
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaDeleteReply::VT_OBJECT_IDS, object_ids);
  }
  void add_errors(flatbuffers::Offset<flatbuffers::Vector<int32_t>> errors) {
    fbb_.AddOffset(PlasmaDeleteReply::VT_ERRORS, errors);
  }
  explicit PlasmaDeleteReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t count = 0,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> errors = 0) {
  PlasmaDeleteReplyBuilder builder_(_fbb);
  builder_.add_errors(errors);
  builder_.add_object_ids(object_ids);
  builder_.add_count(count);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    int32_t count = 0,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
    const std::vector<int32_t> *errors = nullptr) {
  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
  auto errors__ = errors ? _fbb.CreateVector<int32_t>(*errors) : 0;
  return plasma::flatbuf::CreatePlasmaDeleteReply(
      _fbb,
      count,
      object_ids__,
      errors__);
}

flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaContainsRequestT : public flatbuffers::NativeTable {
  typedef PlasmaContainsRequest TableType;
  std::string object_id;
  PlasmaContainsRequestT() {
  }
};

struct PlasmaContainsRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaContainsRequestT NativeTableType;
  typedef PlasmaContainsRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           verifier.EndTable();
  }
  PlasmaContainsRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaContainsRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaContainsRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaContainsRequestBuilder {
  typedef PlasmaContainsRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaContainsRequest::VT_OBJECT_ID, object_id);
  }
  explicit PlasmaContainsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0) {
  PlasmaContainsRequestBuilder builder_(_fbb);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaContainsRequest(
      _fbb,
      object_id__);
}

flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaContainsReplyT : public flatbuffers::NativeTable {
  typedef PlasmaContainsReply TableType;
  std::string object_id;
  int32_t has_object;
  PlasmaContainsReplyT()
      : has_object(0) {
  }
};

struct PlasmaContainsReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaContainsReplyT NativeTableType;
  typedef PlasmaContainsReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_HAS_OBJECT = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  int32_t has_object() const {
    return GetField<int32_t>(VT_HAS_OBJECT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<int32_t>(verifier, VT_HAS_OBJECT) &&
           verifier.EndTable();
  }
  PlasmaContainsReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaContainsReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaContainsReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaContainsReplyBuilder {
  typedef PlasmaContainsReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaContainsReply::VT_OBJECT_ID, object_id);
  }
  void add_has_object(int32_t has_object) {
    fbb_.AddElement<int32_t>(PlasmaContainsReply::VT_HAS_OBJECT, has_object, 0);
  }
  explicit PlasmaContainsReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    int32_t has_object = 0) {
  PlasmaContainsReplyBuilder builder_(_fbb);
  builder_.add_has_object(has_object);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    int32_t has_object = 0) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaContainsReply(
      _fbb,
      object_id__,
      has_object);
}

flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaListRequestT : public flatbuffers::NativeTable {
  typedef PlasmaListRequest TableType;
  PlasmaListRequestT() {
  }
};

struct PlasmaListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaListRequestT NativeTableType;
  typedef PlasmaListRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  PlasmaListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaListRequestBuilder {
  typedef PlasmaListRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit PlasmaListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  PlasmaListRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaListReplyT : public flatbuffers::NativeTable {
  typedef PlasmaListReply TableType;
  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> objects;
  PlasmaListReplyT() {
  }
};

struct PlasmaListReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaListReplyT NativeTableType;
  typedef PlasmaListReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECTS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *objects() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *>(VT_OBJECTS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECTS) &&
           verifier.VerifyVector(objects()) &&
           verifier.VerifyVectorOfTables(objects()) &&
           verifier.EndTable();
  }
  PlasmaListReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaListReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaListReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaListReplyBuilder {
  typedef PlasmaListReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> objects) {
    fbb_.AddOffset(PlasmaListReply::VT_OBJECTS, objects);
  }
  explicit PlasmaListReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> objects = 0) {
  PlasmaListReplyBuilder builder_(_fbb);
  builder_.add_objects(objects);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *objects = nullptr) {
  auto objects__ = objects ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>(*objects) : 0;
  return plasma::flatbuf::CreatePlasmaListReply(
      _fbb,
      objects__);
}

flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaConnectRequestT : public flatbuffers::NativeTable {
  typedef PlasmaConnectRequest TableType;
  PlasmaConnectRequestT() {
  }
};

struct PlasmaConnectRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaConnectRequestT NativeTableType;
  typedef PlasmaConnectRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  PlasmaConnectRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaConnectRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaConnectRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaConnectRequestBuilder {
  typedef PlasmaConnectRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit PlasmaConnectRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  PlasmaConnectRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaConnectReplyT : public flatbuffers::NativeTable {
  typedef PlasmaConnectReply TableType;
  int64_t memory_capacity;
  PlasmaConnectReplyT()
      : memory_capacity(0) {
  }
};

struct PlasmaConnectReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaConnectReplyT NativeTableType;
  typedef PlasmaConnectReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_MEMORY_CAPACITY = 4
  };
  int64_t memory_capacity() const {
    return GetField<int64_t>(VT_MEMORY_CAPACITY, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int64_t>(verifier, VT_MEMORY_CAPACITY) &&
           verifier.EndTable();
  }
  PlasmaConnectReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaConnectReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaConnectReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaConnectReplyBuilder {
  typedef PlasmaConnectReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_memory_capacity(int64_t memory_capacity) {
    fbb_.AddElement<int64_t>(PlasmaConnectReply::VT_MEMORY_CAPACITY, memory_capacity, 0);
  }
  explicit PlasmaConnectReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    int64_t memory_capacity = 0) {
  PlasmaConnectReplyBuilder builder_(_fbb);
  builder_.add_memory_capacity(memory_capacity);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaEvictRequestT : public flatbuffers::NativeTable {
  typedef PlasmaEvictRequest TableType;
  uint64_t num_bytes;
  PlasmaEvictRequestT()
      : num_bytes(0) {
  }
};

struct PlasmaEvictRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaEvictRequestT NativeTableType;
  typedef PlasmaEvictRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NUM_BYTES = 4
  };
  uint64_t num_bytes() const {
    return GetField<uint64_t>(VT_NUM_BYTES, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_NUM_BYTES) &&
           verifier.EndTable();
  }
  PlasmaEvictRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaEvictRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaEvictRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaEvictRequestBuilder {
  typedef PlasmaEvictRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_num_bytes(uint64_t num_bytes) {
    fbb_.AddElement<uint64_t>(PlasmaEvictRequest::VT_NUM_BYTES, num_bytes, 0);
  }
  explicit PlasmaEvictRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t num_bytes = 0) {
  PlasmaEvictRequestBuilder builder_(_fbb);
  builder_.add_num_bytes(num_bytes);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaEvictReplyT : public flatbuffers::NativeTable {
  typedef PlasmaEvictReply TableType;
  uint64_t num_bytes;
  PlasmaEvictReplyT()
      : num_bytes(0) {
  }
};

struct PlasmaEvictReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaEvictReplyT NativeTableType;
  typedef PlasmaEvictReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_NUM_BYTES = 4
  };
  uint64_t num_bytes() const {
    return GetField<uint64_t>(VT_NUM_BYTES, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_NUM_BYTES) &&
           verifier.EndTable();
  }
  PlasmaEvictReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaEvictReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaEvictReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaEvictReplyBuilder {
  typedef PlasmaEvictReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_num_bytes(uint64_t num_bytes) {
    fbb_.AddElement<uint64_t>(PlasmaEvictReply::VT_NUM_BYTES, num_bytes, 0);
  }
  explicit PlasmaEvictReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t num_bytes = 0) {
  PlasmaEvictReplyBuilder builder_(_fbb);
  builder_.add_num_bytes(num_bytes);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaSubscribeRequestT : public flatbuffers::NativeTable {
  typedef PlasmaSubscribeRequest TableType;
  PlasmaSubscribeRequestT() {
  }
};

struct PlasmaSubscribeRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaSubscribeRequestT NativeTableType;
  typedef PlasmaSubscribeRequestBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  PlasmaSubscribeRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaSubscribeRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaSubscribeRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaSubscribeRequestBuilder {
  typedef PlasmaSubscribeRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit PlasmaSubscribeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(
    flatbuffers::FlatBufferBuilder &_fbb) {
  PlasmaSubscribeRequestBuilder builder_(_fbb);
  return builder_.Finish();
}

flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaNotificationT : public flatbuffers::NativeTable {
  typedef PlasmaNotification TableType;
  std::vector<std::unique_ptr<plasma::flatbuf::ObjectInfoT>> object_info;
  PlasmaNotificationT() {
  }
};

struct PlasmaNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaNotificationT NativeTableType;
  typedef PlasmaNotificationBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_INFO = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *object_info() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *>(VT_OBJECT_INFO);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_INFO) &&
           verifier.VerifyVector(object_info()) &&
           verifier.VerifyVectorOfTables(object_info()) &&
           verifier.EndTable();
  }
  PlasmaNotificationT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaNotificationT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaNotification> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaNotificationBuilder {
  typedef PlasmaNotification Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_info(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> object_info) {
    fbb_.AddOffset(PlasmaNotification::VT_OBJECT_INFO, object_info);
  }
  explicit PlasmaNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>> object_info = 0) {
  PlasmaNotificationBuilder builder_(_fbb);
  builder_.add_object_info(object_info);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotificationDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> *object_info = nullptr) {
  auto object_info__ = object_info ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>>(*object_info) : 0;
  return plasma::flatbuf::CreatePlasmaNotification(
      _fbb,
      object_info__);
}

flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaDataRequestT : public flatbuffers::NativeTable {
  typedef PlasmaDataRequest TableType;
  std::string object_id;
  std::string address;
  int32_t port;
  PlasmaDataRequestT()
      : port(0) {
  }
};

struct PlasmaDataRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaDataRequestT NativeTableType;
  typedef PlasmaDataRequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_ADDRESS = 6,
    VT_PORT = 8
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  const flatbuffers::String *address() const {
    return GetPointer<const flatbuffers::String *>(VT_ADDRESS);
  }
  int32_t port() const {
    return GetField<int32_t>(VT_PORT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyOffset(verifier, VT_ADDRESS) &&
           verifier.VerifyString(address()) &&
           VerifyField<int32_t>(verifier, VT_PORT) &&
           verifier.EndTable();
  }
  PlasmaDataRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaDataRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaDataRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaDataRequestBuilder {
  typedef PlasmaDataRequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaDataRequest::VT_OBJECT_ID, object_id);
  }
  void add_address(flatbuffers::Offset<flatbuffers::String> address) {
    fbb_.AddOffset(PlasmaDataRequest::VT_ADDRESS, address);
  }
  void add_port(int32_t port) {
    fbb_.AddElement<int32_t>(PlasmaDataRequest::VT_PORT, port, 0);
  }
  explicit PlasmaDataRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    flatbuffers::Offset<flatbuffers::String> address = 0,
    int32_t port = 0) {
  PlasmaDataRequestBuilder builder_(_fbb);
  builder_.add_port(port);
  builder_.add_address(address);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    const char *address = nullptr,
    int32_t port = 0) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  auto address__ = address ? _fbb.CreateString(address) : 0;
  return plasma::flatbuf::CreatePlasmaDataRequest(
      _fbb,
      object_id__,
      address__,
      port);
}

flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

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) {
  }
};

struct PlasmaDataReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaDataReplyT NativeTableType;
  typedef PlasmaDataReplyBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_ID = 4,
    VT_OBJECT_SIZE = 6,
    VT_METADATA_SIZE = 8
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  uint64_t object_size() const {
    return GetField<uint64_t>(VT_OBJECT_SIZE, 0);
  }
  uint64_t metadata_size() const {
    return GetField<uint64_t>(VT_METADATA_SIZE, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.VerifyString(object_id()) &&
           VerifyField<uint64_t>(verifier, VT_OBJECT_SIZE) &&
           VerifyField<uint64_t>(verifier, VT_METADATA_SIZE) &&
           verifier.EndTable();
  }
  PlasmaDataReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaDataReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaDataReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaDataReplyBuilder {
  typedef PlasmaDataReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaDataReply::VT_OBJECT_ID, object_id);
  }
  void add_object_size(uint64_t object_size) {
    fbb_.AddElement<uint64_t>(PlasmaDataReply::VT_OBJECT_SIZE, object_size, 0);
  }
  void add_metadata_size(uint64_t metadata_size) {
    fbb_.AddElement<uint64_t>(PlasmaDataReply::VT_METADATA_SIZE, metadata_size, 0);
  }
  explicit PlasmaDataReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    uint64_t object_size = 0,
    uint64_t metadata_size = 0) {
  PlasmaDataReplyBuilder builder_(_fbb);
  builder_.add_metadata_size(metadata_size);
  builder_.add_object_size(object_size);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    uint64_t object_size = 0,
    uint64_t metadata_size = 0) {
  auto object_id__ = object_id ? _fbb.CreateString(object_id) : 0;
  return plasma::flatbuf::CreatePlasmaDataReply(
      _fbb,
      object_id__,
      object_size,
      metadata_size);
}

flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaRefreshLRURequestT : public flatbuffers::NativeTable {
  typedef PlasmaRefreshLRURequest TableType;
  std::vector<std::string> object_ids;
  PlasmaRefreshLRURequestT() {
  }
};

struct PlasmaRefreshLRURequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaRefreshLRURequestT NativeTableType;
  typedef PlasmaRefreshLRURequestBuilder Builder;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_OBJECT_IDS = 4
  };
  const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *object_ids() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OBJECT_IDS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.VerifyVector(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           verifier.EndTable();
  }
  PlasmaRefreshLRURequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaRefreshLRURequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaRefreshLRURequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaRefreshLRURequestBuilder {
  typedef PlasmaRefreshLRURequest Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaRefreshLRURequest::VT_OBJECT_IDS, object_ids);
  }
  explicit PlasmaRefreshLRURequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0) {
  PlasmaRefreshLRURequestBuilder builder_(_fbb);
  builder_.add_object_ids(object_ids);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr) {
  auto object_ids__ = object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0;
  return plasma::flatbuf::CreatePlasmaRefreshLRURequest(
      _fbb,
      object_ids__);
}

flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaRefreshLRUReplyT : public flatbuffers::NativeTable {
  typedef PlasmaRefreshLRUReply TableType;
  PlasmaRefreshLRUReplyT() {
  }
};

struct PlasmaRefreshLRUReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaRefreshLRUReplyT NativeTableType;
  typedef PlasmaRefreshLRUReplyBuilder Builder;
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
  PlasmaRefreshLRUReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaRefreshLRUReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaRefreshLRUReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaRefreshLRUReplyBuilder {
  typedef PlasmaRefreshLRUReply Table;
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  explicit PlasmaRefreshLRUReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : 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);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(
    flatbuffers::FlatBufferBuilder &_fbb) {
  PlasmaRefreshLRUReplyBuilder builder_(_fbb);
  return builder_.Finish();
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaSetOptionsRequest::UnPackTo(PlasmaSetOptionsRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = client_name(); if (_e) _o->client_name = _e->str(); }
  { auto _e = output_memory_quota(); _o->output_memory_quota = _e; }
}

inline flatbuffers::Offset<PlasmaSetOptionsRequest> PlasmaSetOptionsRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaSetOptionsRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaSetOptionsRequest> CreatePlasmaSetOptionsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSetOptionsRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _client_name = _o->client_name.empty() ? 0 : _fbb.CreateString(_o->client_name);
  auto _output_memory_quota = _o->output_memory_quota;
  return plasma::flatbuf::CreatePlasmaSetOptionsRequest(
      _fbb,
      _client_name,
      _output_memory_quota);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaSetOptionsReply::UnPackTo(PlasmaSetOptionsReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = error(); _o->error = _e; }
}

inline flatbuffers::Offset<PlasmaSetOptionsReply> PlasmaSetOptionsReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaSetOptionsReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaSetOptionsReply> CreatePlasmaSetOptionsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSetOptionsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSetOptionsReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _error = _o->error;
  return plasma::flatbuf::CreatePlasmaSetOptionsReply(
      _fbb,
      _error);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaGetDebugStringRequest::UnPackTo(PlasmaGetDebugStringRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<PlasmaGetDebugStringRequest> PlasmaGetDebugStringRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaGetDebugStringRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaGetDebugStringRequest> CreatePlasmaGetDebugStringRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetDebugStringRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return plasma::flatbuf::CreatePlasmaGetDebugStringRequest(
      _fbb);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaGetDebugStringReply::UnPackTo(PlasmaGetDebugStringReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = debug_string(); if (_e) _o->debug_string = _e->str(); }
}

inline flatbuffers::Offset<PlasmaGetDebugStringReply> PlasmaGetDebugStringReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaGetDebugStringReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaGetDebugStringReply> CreatePlasmaGetDebugStringReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetDebugStringReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetDebugStringReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _debug_string = _o->debug_string.empty() ? 0 : _fbb.CreateString(_o->debug_string);
  return plasma::flatbuf::CreatePlasmaGetDebugStringReply(
      _fbb,
      _debug_string);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaCreateRequest::UnPackTo(PlasmaCreateRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = evict_if_full(); _o->evict_if_full = _e; }
  { auto _e = data_size(); _o->data_size = _e; }
  { auto _e = metadata_size(); _o->metadata_size = _e; }
  { auto _e = device_num(); _o->device_num = _e; }
}

inline flatbuffers::Offset<PlasmaCreateRequest> PlasmaCreateRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaCreateRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _evict_if_full = _o->evict_if_full;
  auto _data_size = _o->data_size;
  auto _metadata_size = _o->metadata_size;
  auto _device_num = _o->device_num;
  return plasma::flatbuf::CreatePlasmaCreateRequest(
      _fbb,
      _object_id,
      _evict_if_full,
      _data_size,
      _metadata_size,
      _device_num);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void CudaHandle::UnPackTo(CudaHandleT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = handle(); if (_e) { _o->handle.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->handle[_i] = _e->Get(_i); } } }
}

inline flatbuffers::Offset<CudaHandle> CudaHandle::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateCudaHandle(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<CudaHandle> CreateCudaHandle(flatbuffers::FlatBufferBuilder &_fbb, const CudaHandleT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CudaHandleT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _handle = _o->handle.size() ? _fbb.CreateVector(_o->handle) : 0;
  return plasma::flatbuf::CreateCudaHandle(
      _fbb,
      _handle);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaCreateReply::UnPackTo(PlasmaCreateReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = plasma_object(); if (_e) _o->plasma_object = std::unique_ptr<plasma::flatbuf::PlasmaObjectSpec>(new plasma::flatbuf::PlasmaObjectSpec(*_e)); }
  { auto _e = error(); _o->error = _e; }
  { auto _e = store_fd(); _o->store_fd = _e; }
  { auto _e = mmap_size(); _o->mmap_size = _e; }
  { auto _e = ipc_handle(); if (_e) _o->ipc_handle = std::unique_ptr<plasma::flatbuf::CudaHandleT>(_e->UnPack(_resolver)); }
}

inline flatbuffers::Offset<PlasmaCreateReply> PlasmaCreateReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaCreateReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _plasma_object = _o->plasma_object ? _o->plasma_object.get() : 0;
  auto _error = _o->error;
  auto _store_fd = _o->store_fd;
  auto _mmap_size = _o->mmap_size;
  auto _ipc_handle = _o->ipc_handle ? CreateCudaHandle(_fbb, _o->ipc_handle.get(), _rehasher) : 0;
  return plasma::flatbuf::CreatePlasmaCreateReply(
      _fbb,
      _object_id,
      _plasma_object,
      _error,
      _store_fd,
      _mmap_size,
      _ipc_handle);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaCreateAndSealRequest::UnPackTo(PlasmaCreateAndSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = evict_if_full(); _o->evict_if_full = _e; }
  { auto _e = data(); if (_e) _o->data = _e->str(); }
  { auto _e = metadata(); if (_e) _o->metadata = _e->str(); }
  { auto _e = digest(); if (_e) _o->digest = _e->str(); }
}

inline flatbuffers::Offset<PlasmaCreateAndSealRequest> PlasmaCreateAndSealRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaCreateAndSealRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaCreateAndSealRequest> CreatePlasmaCreateAndSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _evict_if_full = _o->evict_if_full;
  auto _data = _o->data.empty() ? 0 : _fbb.CreateString(_o->data);
  auto _metadata = _o->metadata.empty() ? 0 : _fbb.CreateString(_o->metadata);
  auto _digest = _o->digest.empty() ? 0 : _fbb.CreateString(_o->digest);
  return plasma::flatbuf::CreatePlasmaCreateAndSealRequest(
      _fbb,
      _object_id,
      _evict_if_full,
      _data,
      _metadata,
      _digest);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaCreateAndSealReply::UnPackTo(PlasmaCreateAndSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = error(); _o->error = _e; }
}

inline flatbuffers::Offset<PlasmaCreateAndSealReply> PlasmaCreateAndSealReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaCreateAndSealReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaCreateAndSealReply> CreatePlasmaCreateAndSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _error = _o->error;
  return plasma::flatbuf::CreatePlasmaCreateAndSealReply(
      _fbb,
      _error);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaCreateAndSealBatchRequest::UnPackTo(PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
  { auto _e = evict_if_full(); _o->evict_if_full = _e; }
  { auto _e = data(); if (_e) { _o->data.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->data[_i] = _e->Get(_i)->str(); } } }
  { auto _e = metadata(); if (_e) { _o->metadata.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->metadata[_i] = _e->Get(_i)->str(); } } }
  { auto _e = digest(); if (_e) { _o->digest.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->digest[_i] = _e->Get(_i)->str(); } } }
}

inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> PlasmaCreateAndSealBatchRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaCreateAndSealBatchRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaCreateAndSealBatchRequest> CreatePlasmaCreateAndSealBatchRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealBatchRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  auto _evict_if_full = _o->evict_if_full;
  auto _data = _o->data.size() ? _fbb.CreateVectorOfStrings(_o->data) : 0;
  auto _metadata = _o->metadata.size() ? _fbb.CreateVectorOfStrings(_o->metadata) : 0;
  auto _digest = _o->digest.size() ? _fbb.CreateVectorOfStrings(_o->digest) : 0;
  return plasma::flatbuf::CreatePlasmaCreateAndSealBatchRequest(
      _fbb,
      _object_ids,
      _evict_if_full,
      _data,
      _metadata,
      _digest);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaCreateAndSealBatchReply::UnPackTo(PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = error(); _o->error = _e; }
}

inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> PlasmaCreateAndSealBatchReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaCreateAndSealBatchReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaCreateAndSealBatchReply> CreatePlasmaCreateAndSealBatchReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaCreateAndSealBatchReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaCreateAndSealBatchReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _error = _o->error;
  return plasma::flatbuf::CreatePlasmaCreateAndSealBatchReply(
      _fbb,
      _error);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaAbortRequest::UnPackTo(PlasmaAbortRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
}

inline flatbuffers::Offset<PlasmaAbortRequest> PlasmaAbortRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaAbortRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaAbortRequest> CreatePlasmaAbortRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaAbortRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  return plasma::flatbuf::CreatePlasmaAbortRequest(
      _fbb,
      _object_id);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaAbortReply::UnPackTo(PlasmaAbortReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
}

inline flatbuffers::Offset<PlasmaAbortReply> PlasmaAbortReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaAbortReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaAbortReply> CreatePlasmaAbortReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaAbortReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaAbortReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  return plasma::flatbuf::CreatePlasmaAbortReply(
      _fbb,
      _object_id);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaSealRequest::UnPackTo(PlasmaSealRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = digest(); if (_e) _o->digest = _e->str(); }
}

inline flatbuffers::Offset<PlasmaSealRequest> PlasmaSealRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaSealRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaSealRequest> CreatePlasmaSealRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSealRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _digest = _o->digest.empty() ? 0 : _fbb.CreateString(_o->digest);
  return plasma::flatbuf::CreatePlasmaSealRequest(
      _fbb,
      _object_id,
      _digest);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaSealReply::UnPackTo(PlasmaSealReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = error(); _o->error = _e; }
}

inline flatbuffers::Offset<PlasmaSealReply> PlasmaSealReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaSealReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSealReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSealReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _error = _o->error;
  return plasma::flatbuf::CreatePlasmaSealReply(
      _fbb,
      _object_id,
      _error);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaGetRequest::UnPackTo(PlasmaGetRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
  { auto _e = timeout_ms(); _o->timeout_ms = _e; }
}

inline flatbuffers::Offset<PlasmaGetRequest> PlasmaGetRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaGetRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaGetRequest> CreatePlasmaGetRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  auto _timeout_ms = _o->timeout_ms;
  return plasma::flatbuf::CreatePlasmaGetRequest(
      _fbb,
      _object_ids,
      _timeout_ms);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaGetReply::UnPackTo(PlasmaGetReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
  { auto _e = plasma_objects(); if (_e) { _o->plasma_objects.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->plasma_objects[_i] = *_e->Get(_i); } } }
  { auto _e = store_fds(); if (_e) { _o->store_fds.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->store_fds[_i] = _e->Get(_i); } } }
  { auto _e = mmap_sizes(); if (_e) { _o->mmap_sizes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->mmap_sizes[_i] = _e->Get(_i); } } }
  { auto _e = handles(); if (_e) { _o->handles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->handles[_i] = std::unique_ptr<plasma::flatbuf::CudaHandleT>(_e->Get(_i)->UnPack(_resolver)); } } }
}

inline flatbuffers::Offset<PlasmaGetReply> PlasmaGetReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaGetReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaGetReply> CreatePlasmaGetReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaGetReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaGetReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  auto _plasma_objects = _o->plasma_objects.size() ? _fbb.CreateVectorOfStructs(_o->plasma_objects) : 0;
  auto _store_fds = _o->store_fds.size() ? _fbb.CreateVector(_o->store_fds) : 0;
  auto _mmap_sizes = _o->mmap_sizes.size() ? _fbb.CreateVector(_o->mmap_sizes) : 0;
  auto _handles = _o->handles.size() ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::CudaHandle>> (_o->handles.size(), [](size_t i, _VectorArgs *__va) { return CreateCudaHandle(*__va->__fbb, __va->__o->handles[i].get(), __va->__rehasher); }, &_va ) : 0;
  return plasma::flatbuf::CreatePlasmaGetReply(
      _fbb,
      _object_ids,
      _plasma_objects,
      _store_fds,
      _mmap_sizes,
      _handles);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaReleaseRequest::UnPackTo(PlasmaReleaseRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
}

inline flatbuffers::Offset<PlasmaReleaseRequest> PlasmaReleaseRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaReleaseRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaReleaseRequest> CreatePlasmaReleaseRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaReleaseRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  return plasma::flatbuf::CreatePlasmaReleaseRequest(
      _fbb,
      _object_id);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaReleaseReply::UnPackTo(PlasmaReleaseReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = error(); _o->error = _e; }
}

inline flatbuffers::Offset<PlasmaReleaseReply> PlasmaReleaseReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaReleaseReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaReleaseReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaReleaseReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _error = _o->error;
  return plasma::flatbuf::CreatePlasmaReleaseReply(
      _fbb,
      _object_id,
      _error);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaDeleteRequest::UnPackTo(PlasmaDeleteRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = count(); _o->count = _e; }
  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
}

inline flatbuffers::Offset<PlasmaDeleteRequest> PlasmaDeleteRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaDeleteRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDeleteRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _count = _o->count;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  return plasma::flatbuf::CreatePlasmaDeleteRequest(
      _fbb,
      _count,
      _object_ids);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaDeleteReply::UnPackTo(PlasmaDeleteReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = count(); _o->count = _e; }
  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
  { auto _e = errors(); if (_e) { _o->errors.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->errors[_i] = static_cast<plasma::flatbuf::PlasmaError>(_e->Get(_i)); } } }
}

inline flatbuffers::Offset<PlasmaDeleteReply> PlasmaDeleteReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaDeleteReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDeleteReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDeleteReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _count = _o->count;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  auto _errors = _o->errors.size() ? _fbb.CreateVectorScalarCast<int32_t>(flatbuffers::data(_o->errors), _o->errors.size()) : 0;
  return plasma::flatbuf::CreatePlasmaDeleteReply(
      _fbb,
      _count,
      _object_ids,
      _errors);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaContainsRequest::UnPackTo(PlasmaContainsRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
}

inline flatbuffers::Offset<PlasmaContainsRequest> PlasmaContainsRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaContainsRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaContainsRequest> CreatePlasmaContainsRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaContainsRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  return plasma::flatbuf::CreatePlasmaContainsRequest(
      _fbb,
      _object_id);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaContainsReply::UnPackTo(PlasmaContainsReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = has_object(); _o->has_object = _e; }
}

inline flatbuffers::Offset<PlasmaContainsReply> PlasmaContainsReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaContainsReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaContainsReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _has_object = _o->has_object;
  return plasma::flatbuf::CreatePlasmaContainsReply(
      _fbb,
      _object_id,
      _has_object);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaListRequest::UnPackTo(PlasmaListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<PlasmaListRequest> PlasmaListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaListRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaListRequest> CreatePlasmaListRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaListRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return plasma::flatbuf::CreatePlasmaListRequest(
      _fbb);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaListReply::UnPackTo(PlasmaListReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = objects(); if (_e) { _o->objects.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->objects[_i] = std::unique_ptr<plasma::flatbuf::ObjectInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
}

inline flatbuffers::Offset<PlasmaListReply> PlasmaListReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaListReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaListReply> CreatePlasmaListReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaListReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaListReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _objects = _o->objects.size() ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> (_o->objects.size(), [](size_t i, _VectorArgs *__va) { return CreateObjectInfo(*__va->__fbb, __va->__o->objects[i].get(), __va->__rehasher); }, &_va ) : 0;
  return plasma::flatbuf::CreatePlasmaListReply(
      _fbb,
      _objects);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaConnectRequest::UnPackTo(PlasmaConnectRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<PlasmaConnectRequest> PlasmaConnectRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaConnectRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaConnectRequest> CreatePlasmaConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaConnectRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return plasma::flatbuf::CreatePlasmaConnectRequest(
      _fbb);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaConnectReply::UnPackTo(PlasmaConnectReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = memory_capacity(); _o->memory_capacity = _e; }
}

inline flatbuffers::Offset<PlasmaConnectReply> PlasmaConnectReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaConnectReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaConnectReply> CreatePlasmaConnectReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaConnectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaConnectReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _memory_capacity = _o->memory_capacity;
  return plasma::flatbuf::CreatePlasmaConnectReply(
      _fbb,
      _memory_capacity);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaEvictRequest::UnPackTo(PlasmaEvictRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = num_bytes(); _o->num_bytes = _e; }
}

inline flatbuffers::Offset<PlasmaEvictRequest> PlasmaEvictRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaEvictRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaEvictRequest> CreatePlasmaEvictRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaEvictRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _num_bytes = _o->num_bytes;
  return plasma::flatbuf::CreatePlasmaEvictRequest(
      _fbb,
      _num_bytes);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaEvictReply::UnPackTo(PlasmaEvictReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = num_bytes(); _o->num_bytes = _e; }
}

inline flatbuffers::Offset<PlasmaEvictReply> PlasmaEvictReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaEvictReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaEvictReply> CreatePlasmaEvictReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaEvictReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaEvictReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _num_bytes = _o->num_bytes;
  return plasma::flatbuf::CreatePlasmaEvictReply(
      _fbb,
      _num_bytes);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaSubscribeRequest::UnPackTo(PlasmaSubscribeRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<PlasmaSubscribeRequest> PlasmaSubscribeRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaSubscribeRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaSubscribeRequest> CreatePlasmaSubscribeRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaSubscribeRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaSubscribeRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return plasma::flatbuf::CreatePlasmaSubscribeRequest(
      _fbb);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaNotification::UnPackTo(PlasmaNotificationT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_info(); if (_e) { _o->object_info.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_info[_i] = std::unique_ptr<plasma::flatbuf::ObjectInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
}

inline flatbuffers::Offset<PlasmaNotification> PlasmaNotification::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaNotification(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaNotification> CreatePlasmaNotification(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaNotificationT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaNotificationT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_info = _o->object_info.size() ? _fbb.CreateVector<flatbuffers::Offset<plasma::flatbuf::ObjectInfo>> (_o->object_info.size(), [](size_t i, _VectorArgs *__va) { return CreateObjectInfo(*__va->__fbb, __va->__o->object_info[i].get(), __va->__rehasher); }, &_va ) : 0;
  return plasma::flatbuf::CreatePlasmaNotification(
      _fbb,
      _object_info);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaDataRequest::UnPackTo(PlasmaDataRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = address(); if (_e) _o->address = _e->str(); }
  { auto _e = port(); _o->port = _e; }
}

inline flatbuffers::Offset<PlasmaDataRequest> PlasmaDataRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaDataRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaDataRequest> CreatePlasmaDataRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDataRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _address = _o->address.empty() ? 0 : _fbb.CreateString(_o->address);
  auto _port = _o->port;
  return plasma::flatbuf::CreatePlasmaDataRequest(
      _fbb,
      _object_id,
      _address,
      _port);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaDataReply::UnPackTo(PlasmaDataReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_id(); if (_e) _o->object_id = _e->str(); }
  { auto _e = object_size(); _o->object_size = _e; }
  { auto _e = metadata_size(); _o->metadata_size = _e; }
}

inline flatbuffers::Offset<PlasmaDataReply> PlasmaDataReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaDataReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaDataReply> CreatePlasmaDataReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaDataReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaDataReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_id = _o->object_id.empty() ? 0 : _fbb.CreateString(_o->object_id);
  auto _object_size = _o->object_size;
  auto _metadata_size = _o->metadata_size;
  return plasma::flatbuf::CreatePlasmaDataReply(
      _fbb,
      _object_id,
      _object_size,
      _metadata_size);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaRefreshLRURequest::UnPackTo(PlasmaRefreshLRURequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_ids(); if (_e) { _o->object_ids.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_ids[_i] = _e->Get(_i)->str(); } } }
}

inline flatbuffers::Offset<PlasmaRefreshLRURequest> PlasmaRefreshLRURequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaRefreshLRURequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaRefreshLRURequest> CreatePlasmaRefreshLRURequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRURequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaRefreshLRURequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  return plasma::flatbuf::CreatePlasmaRefreshLRURequest(
      _fbb,
      _object_ids);
}

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());
  UnPackTo(_o.get(), _resolver);
  return _o.release();
}

inline void PlasmaRefreshLRUReply::UnPackTo(PlasmaRefreshLRUReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
}

inline flatbuffers::Offset<PlasmaRefreshLRUReply> PlasmaRefreshLRUReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaRefreshLRUReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaRefreshLRUReply> CreatePlasmaRefreshLRUReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaRefreshLRUReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const PlasmaRefreshLRUReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
  return plasma::flatbuf::CreatePlasmaRefreshLRUReply(
      _fbb);
}

}  // namespace flatbuf
}  // namespace plasma

#endif  // FLATBUFFERS_GENERATED_PLASMA_PLASMA_FLATBUF_H_