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


#ifndef FLATBUFFERS_GENERATED_PLASMA_H_
#define FLATBUFFERS_GENERATED_PLASMA_H_

#include "flatbuffers/flatbuffers.h"

struct PlasmaObjectSpec;

struct PlasmaCreateRequest;
struct PlasmaCreateRequestT;

struct CudaHandle;
struct CudaHandleT;

struct PlasmaCreateReply;
struct PlasmaCreateReplyT;

struct PlasmaAbortRequest;
struct PlasmaAbortRequestT;

struct PlasmaAbortReply;
struct PlasmaAbortReplyT;

struct PlasmaSealRequest;
struct PlasmaSealRequestT;

struct PlasmaSealReply;
struct PlasmaSealReplyT;

struct PlasmaGetRequest;
struct PlasmaGetRequestT;

struct PlasmaGetReply;
struct PlasmaGetReplyT;

struct PlasmaReleaseRequest;
struct PlasmaReleaseRequestT;

struct PlasmaReleaseReply;
struct PlasmaReleaseReplyT;

struct PlasmaDeleteRequest;
struct PlasmaDeleteRequestT;

struct PlasmaDeleteReply;
struct PlasmaDeleteReplyT;

struct PlasmaStatusRequest;
struct PlasmaStatusRequestT;

struct PlasmaStatusReply;
struct PlasmaStatusReplyT;

struct PlasmaContainsRequest;
struct PlasmaContainsRequestT;

struct PlasmaContainsReply;
struct PlasmaContainsReplyT;

struct PlasmaConnectRequest;
struct PlasmaConnectRequestT;

struct PlasmaConnectReply;
struct PlasmaConnectReplyT;

struct PlasmaEvictRequest;
struct PlasmaEvictRequestT;

struct PlasmaEvictReply;
struct PlasmaEvictReplyT;

struct PlasmaFetchRequest;
struct PlasmaFetchRequestT;

struct ObjectRequestSpec;
struct ObjectRequestSpecT;

struct PlasmaWaitRequest;
struct PlasmaWaitRequestT;

struct ObjectReply;
struct ObjectReplyT;

struct PlasmaWaitReply;
struct PlasmaWaitReplyT;

struct PlasmaSubscribeRequest;
struct PlasmaSubscribeRequestT;

struct PlasmaDataRequest;
struct PlasmaDataRequestT;

struct PlasmaDataReply;
struct PlasmaDataReplyT;

enum MessageType {
  MessageType_PlasmaCreateRequest = 1,
  MessageType_PlasmaCreateReply = 2,
  MessageType_PlasmaAbortRequest = 3,
  MessageType_PlasmaAbortReply = 4,
  MessageType_PlasmaSealRequest = 5,
  MessageType_PlasmaSealReply = 6,
  MessageType_PlasmaGetRequest = 7,
  MessageType_PlasmaGetReply = 8,
  MessageType_PlasmaReleaseRequest = 9,
  MessageType_PlasmaReleaseReply = 10,
  MessageType_PlasmaDeleteRequest = 11,
  MessageType_PlasmaDeleteReply = 12,
  MessageType_PlasmaStatusRequest = 13,
  MessageType_PlasmaStatusReply = 14,
  MessageType_PlasmaContainsRequest = 15,
  MessageType_PlasmaContainsReply = 16,
  MessageType_PlasmaConnectRequest = 17,
  MessageType_PlasmaConnectReply = 18,
  MessageType_PlasmaEvictRequest = 19,
  MessageType_PlasmaEvictReply = 20,
  MessageType_PlasmaFetchRequest = 21,
  MessageType_PlasmaWaitRequest = 22,
  MessageType_PlasmaWaitReply = 23,
  MessageType_PlasmaSubscribeRequest = 24,
  MessageType_PlasmaUnsubscribeRequest = 25,
  MessageType_PlasmaDataRequest = 26,
  MessageType_PlasmaDataReply = 27,
  MessageType_PlasmaNotification = 28,
  MessageType_MIN = MessageType_PlasmaCreateRequest,
  MessageType_MAX = MessageType_PlasmaNotification
};

inline MessageType (&EnumValuesMessageType())[28] {
  static MessageType values[] = {
    MessageType_PlasmaCreateRequest,
    MessageType_PlasmaCreateReply,
    MessageType_PlasmaAbortRequest,
    MessageType_PlasmaAbortReply,
    MessageType_PlasmaSealRequest,
    MessageType_PlasmaSealReply,
    MessageType_PlasmaGetRequest,
    MessageType_PlasmaGetReply,
    MessageType_PlasmaReleaseRequest,
    MessageType_PlasmaReleaseReply,
    MessageType_PlasmaDeleteRequest,
    MessageType_PlasmaDeleteReply,
    MessageType_PlasmaStatusRequest,
    MessageType_PlasmaStatusReply,
    MessageType_PlasmaContainsRequest,
    MessageType_PlasmaContainsReply,
    MessageType_PlasmaConnectRequest,
    MessageType_PlasmaConnectReply,
    MessageType_PlasmaEvictRequest,
    MessageType_PlasmaEvictReply,
    MessageType_PlasmaFetchRequest,
    MessageType_PlasmaWaitRequest,
    MessageType_PlasmaWaitReply,
    MessageType_PlasmaSubscribeRequest,
    MessageType_PlasmaUnsubscribeRequest,
    MessageType_PlasmaDataRequest,
    MessageType_PlasmaDataReply,
    MessageType_PlasmaNotification
  };
  return values;
}

inline const char **EnumNamesMessageType() {
  static const char *names[] = {
    "PlasmaCreateRequest",
    "PlasmaCreateReply",
    "PlasmaAbortRequest",
    "PlasmaAbortReply",
    "PlasmaSealRequest",
    "PlasmaSealReply",
    "PlasmaGetRequest",
    "PlasmaGetReply",
    "PlasmaReleaseRequest",
    "PlasmaReleaseReply",
    "PlasmaDeleteRequest",
    "PlasmaDeleteReply",
    "PlasmaStatusRequest",
    "PlasmaStatusReply",
    "PlasmaContainsRequest",
    "PlasmaContainsReply",
    "PlasmaConnectRequest",
    "PlasmaConnectReply",
    "PlasmaEvictRequest",
    "PlasmaEvictReply",
    "PlasmaFetchRequest",
    "PlasmaWaitRequest",
    "PlasmaWaitReply",
    "PlasmaSubscribeRequest",
    "PlasmaUnsubscribeRequest",
    "PlasmaDataRequest",
    "PlasmaDataReply",
    "PlasmaNotification",
    nullptr
  };
  return names;
}

inline const char *EnumNameMessageType(MessageType e) {
  const size_t index = static_cast<int>(e) - static_cast<int>(MessageType_PlasmaCreateRequest);
  return EnumNamesMessageType()[index];
}

enum PlasmaError {
  PlasmaError_OK = 0,
  PlasmaError_ObjectExists = 1,
  PlasmaError_ObjectNonexistent = 2,
  PlasmaError_OutOfMemory = 3,
  PlasmaError_ObjectNotSealed = 4,
  PlasmaError_ObjectInUse = 5,
  PlasmaError_MIN = PlasmaError_OK,
  PlasmaError_MAX = PlasmaError_ObjectInUse
};

inline PlasmaError (&EnumValuesPlasmaError())[6] {
  static PlasmaError values[] = {
    PlasmaError_OK,
    PlasmaError_ObjectExists,
    PlasmaError_ObjectNonexistent,
    PlasmaError_OutOfMemory,
    PlasmaError_ObjectNotSealed,
    PlasmaError_ObjectInUse
  };
  return values;
}

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

inline const char *EnumNamePlasmaError(PlasmaError e) {
  const size_t index = static_cast<int>(e);
  return EnumNamesPlasmaError()[index];
}

enum ObjectStatus {
  ObjectStatus_Local = 1,
  ObjectStatus_Remote = 2,
  ObjectStatus_Nonexistent = 3,
  ObjectStatus_Transfer = 4,
  ObjectStatus_MIN = ObjectStatus_Local,
  ObjectStatus_MAX = ObjectStatus_Transfer
};

inline ObjectStatus (&EnumValuesObjectStatus())[4] {
  static ObjectStatus values[] = {
    ObjectStatus_Local,
    ObjectStatus_Remote,
    ObjectStatus_Nonexistent,
    ObjectStatus_Transfer
  };
  return values;
}

inline const char **EnumNamesObjectStatus() {
  static const char *names[] = {
    "Local",
    "Remote",
    "Nonexistent",
    "Transfer",
    nullptr
  };
  return names;
}

inline const char *EnumNameObjectStatus(ObjectStatus e) {
  const size_t index = static_cast<int>(e) - static_cast<int>(ObjectStatus_Local);
  return EnumNamesObjectStatus()[index];
}

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(this, 0, sizeof(PlasmaObjectSpec));
  }
  PlasmaObjectSpec(const PlasmaObjectSpec &_o) {
    memcpy(this, &_o, 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_);
  }
};
STRUCT_END(PlasmaObjectSpec, 48);

struct PlasmaCreateRequestT : public flatbuffers::NativeTable {
  typedef PlasmaCreateRequest TableType;
  std::string object_id;
  uint64_t data_size;
  uint64_t metadata_size;
  int32_t device_num;
  PlasmaCreateRequestT()
      : data_size(0),
        metadata_size(0),
        device_num(0) {
  }
};

struct PlasmaCreateRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateRequestT NativeTableType;
  enum {
    VT_OBJECT_ID = 4,
    VT_DATA_SIZE = 6,
    VT_METADATA_SIZE = 8,
    VT_DEVICE_NUM = 10
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  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.Verify(object_id()) &&
           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 {
  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_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);
  }
  PlasmaCreateRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaCreateRequestBuilder &operator=(const PlasmaCreateRequestBuilder &);
  flatbuffers::Offset<PlasmaCreateRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 4);
    auto o = flatbuffers::Offset<PlasmaCreateRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    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);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaCreateRequest> CreatePlasmaCreateRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    uint64_t data_size = 0,
    uint64_t metadata_size = 0,
    int32_t device_num = 0) {
  return CreatePlasmaCreateRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      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;
  enum {
    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.Verify(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 {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_handle(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> handle) {
    fbb_.AddOffset(CudaHandle::VT_HANDLE, handle);
  }
  CudaHandleBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  CudaHandleBuilder &operator=(const CudaHandleBuilder &);
  flatbuffers::Offset<CudaHandle> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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) {
  return CreateCudaHandle(
      _fbb,
      handle ? _fbb.CreateVector<uint8_t>(*handle) : 0);
}

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<PlasmaObjectSpec> plasma_object;
  PlasmaError error;
  int32_t store_fd;
  int64_t mmap_size;
  std::unique_ptr<CudaHandleT> ipc_handle;
  PlasmaCreateReplyT()
      : error(PlasmaError_OK),
        store_fd(0),
        mmap_size(0) {
  }
};

struct PlasmaCreateReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaCreateReplyT NativeTableType;
  enum {
    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 PlasmaObjectSpec *plasma_object() const {
    return GetStruct<const PlasmaObjectSpec *>(VT_PLASMA_OBJECT);
  }
  PlasmaError error() const {
    return static_cast<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 CudaHandle *ipc_handle() const {
    return GetPointer<const CudaHandle *>(VT_IPC_HANDLE);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.Verify(object_id()) &&
           VerifyField<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 {
  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 PlasmaObjectSpec *plasma_object) {
    fbb_.AddStruct(PlasmaCreateReply::VT_PLASMA_OBJECT, plasma_object);
  }
  void add_error(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<CudaHandle> ipc_handle) {
    fbb_.AddOffset(PlasmaCreateReply::VT_IPC_HANDLE, ipc_handle);
  }
  PlasmaCreateReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaCreateReplyBuilder &operator=(const PlasmaCreateReplyBuilder &);
  flatbuffers::Offset<PlasmaCreateReply> Finish() {
    const auto end = fbb_.EndTable(start_, 6);
    auto o = flatbuffers::Offset<PlasmaCreateReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaCreateReply> CreatePlasmaCreateReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    const PlasmaObjectSpec *plasma_object = 0,
    PlasmaError error = PlasmaError_OK,
    int32_t store_fd = 0,
    int64_t mmap_size = 0,
    flatbuffers::Offset<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 PlasmaObjectSpec *plasma_object = 0,
    PlasmaError error = PlasmaError_OK,
    int32_t store_fd = 0,
    int64_t mmap_size = 0,
    flatbuffers::Offset<CudaHandle> ipc_handle = 0) {
  return CreatePlasmaCreateReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      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 PlasmaAbortRequestT : public flatbuffers::NativeTable {
  typedef PlasmaAbortRequest TableType;
  std::string object_id;
  PlasmaAbortRequestT() {
  }
};

struct PlasmaAbortRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaAbortRequestT NativeTableType;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaAbortRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaAbortRequestBuilder &operator=(const PlasmaAbortRequestBuilder &);
  flatbuffers::Offset<PlasmaAbortRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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) {
  return CreatePlasmaAbortRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0);
}

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;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaAbortReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaAbortReplyBuilder &operator=(const PlasmaAbortReplyBuilder &);
  flatbuffers::Offset<PlasmaAbortReply> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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) {
  return CreatePlasmaAbortReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0);
}

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;
  enum {
    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.Verify(object_id()) &&
           VerifyOffset(verifier, VT_DIGEST) &&
           verifier.Verify(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 {
  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);
  }
  PlasmaSealRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaSealRequestBuilder &operator=(const PlasmaSealRequestBuilder &);
  flatbuffers::Offset<PlasmaSealRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    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) {
  return CreatePlasmaSealRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      digest ? _fbb.CreateString(digest) : 0);
}

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;
  PlasmaError error;
  PlasmaSealReplyT()
      : error(PlasmaError_OK) {
  }
};

struct PlasmaSealReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaSealReplyT NativeTableType;
  enum {
    VT_OBJECT_ID = 4,
    VT_ERROR = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  PlasmaError error() const {
    return static_cast<PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.Verify(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 {
  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(PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaSealReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  PlasmaSealReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaSealReplyBuilder &operator=(const PlasmaSealReplyBuilder &);
  flatbuffers::Offset<PlasmaSealReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<PlasmaSealReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaSealReply> CreatePlasmaSealReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    PlasmaError error = 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,
    PlasmaError error = PlasmaError_OK) {
  return CreatePlasmaSealReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      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;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaGetRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaGetRequestBuilder &operator=(const PlasmaGetRequestBuilder &);
  flatbuffers::Offset<PlasmaGetRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    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) {
  return CreatePlasmaGetRequest(
      _fbb,
      object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0,
      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<PlasmaObjectSpec> plasma_objects;
  std::vector<int32_t> store_fds;
  std::vector<int64_t> mmap_sizes;
  std::vector<std::unique_ptr<CudaHandleT>> handles;
  PlasmaGetReplyT() {
  }
};

struct PlasmaGetReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaGetReplyT NativeTableType;
  enum {
    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 PlasmaObjectSpec *> *plasma_objects() const {
    return GetPointer<const flatbuffers::Vector<const 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<CudaHandle>> *handles() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<CudaHandle>> *>(VT_HANDLES);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.Verify(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           VerifyOffset(verifier, VT_PLASMA_OBJECTS) &&
           verifier.Verify(plasma_objects()) &&
           VerifyOffset(verifier, VT_STORE_FDS) &&
           verifier.Verify(store_fds()) &&
           VerifyOffset(verifier, VT_MMAP_SIZES) &&
           verifier.Verify(mmap_sizes()) &&
           VerifyOffset(verifier, VT_HANDLES) &&
           verifier.Verify(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 {
  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 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<CudaHandle>>> handles) {
    fbb_.AddOffset(PlasmaGetReply::VT_HANDLES, handles);
  }
  PlasmaGetReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaGetReplyBuilder &operator=(const PlasmaGetReplyBuilder &);
  flatbuffers::Offset<PlasmaGetReply> Finish() {
    const auto end = fbb_.EndTable(start_, 5);
    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 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<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<const 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<CudaHandle>> *handles = nullptr) {
  return CreatePlasmaGetReply(
      _fbb,
      object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0,
      plasma_objects ? _fbb.CreateVector<const PlasmaObjectSpec *>(*plasma_objects) : 0,
      store_fds ? _fbb.CreateVector<int32_t>(*store_fds) : 0,
      mmap_sizes ? _fbb.CreateVector<int64_t>(*mmap_sizes) : 0,
      handles ? _fbb.CreateVector<flatbuffers::Offset<CudaHandle>>(*handles) : 0);
}

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;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaReleaseRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaReleaseRequestBuilder &operator=(const PlasmaReleaseRequestBuilder &);
  flatbuffers::Offset<PlasmaReleaseRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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) {
  return CreatePlasmaReleaseRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0);
}

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;
  PlasmaError error;
  PlasmaReleaseReplyT()
      : error(PlasmaError_OK) {
  }
};

struct PlasmaReleaseReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaReleaseReplyT NativeTableType;
  enum {
    VT_OBJECT_ID = 4,
    VT_ERROR = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  PlasmaError error() const {
    return static_cast<PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.Verify(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 {
  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(PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaReleaseReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  PlasmaReleaseReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaReleaseReplyBuilder &operator=(const PlasmaReleaseReplyBuilder &);
  flatbuffers::Offset<PlasmaReleaseReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<PlasmaReleaseReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaReleaseReply> CreatePlasmaReleaseReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    PlasmaError error = 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,
    PlasmaError error = PlasmaError_OK) {
  return CreatePlasmaReleaseReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      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;
  std::string object_id;
  PlasmaDeleteRequestT() {
  }
};

struct PlasmaDeleteRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaDeleteRequestT NativeTableType;
  enum {
    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.Verify(object_id()) &&
           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 {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaDeleteRequest::VT_OBJECT_ID, object_id);
  }
  PlasmaDeleteRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaDeleteRequestBuilder &operator=(const PlasmaDeleteRequestBuilder &);
  flatbuffers::Offset<PlasmaDeleteRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    auto o = flatbuffers::Offset<PlasmaDeleteRequest>(end);
    return o;
  }
};

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

inline flatbuffers::Offset<PlasmaDeleteRequest> CreatePlasmaDeleteRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr) {
  return CreatePlasmaDeleteRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0);
}

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;
  std::string object_id;
  PlasmaError error;
  PlasmaDeleteReplyT()
      : error(PlasmaError_OK) {
  }
};

struct PlasmaDeleteReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaDeleteReplyT NativeTableType;
  enum {
    VT_OBJECT_ID = 4,
    VT_ERROR = 6
  };
  const flatbuffers::String *object_id() const {
    return GetPointer<const flatbuffers::String *>(VT_OBJECT_ID);
  }
  PlasmaError error() const {
    return static_cast<PlasmaError>(GetField<int32_t>(VT_ERROR, 0));
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_ID) &&
           verifier.Verify(object_id()) &&
           VerifyField<int32_t>(verifier, VT_ERROR) &&
           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 {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(PlasmaDeleteReply::VT_OBJECT_ID, object_id);
  }
  void add_error(PlasmaError error) {
    fbb_.AddElement<int32_t>(PlasmaDeleteReply::VT_ERROR, static_cast<int32_t>(error), 0);
  }
  PlasmaDeleteReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaDeleteReplyBuilder &operator=(const PlasmaDeleteReplyBuilder &);
  flatbuffers::Offset<PlasmaDeleteReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<PlasmaDeleteReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    PlasmaError error = PlasmaError_OK) {
  PlasmaDeleteReplyBuilder builder_(_fbb);
  builder_.add_error(error);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaDeleteReply> CreatePlasmaDeleteReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    PlasmaError error = PlasmaError_OK) {
  return CreatePlasmaDeleteReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      error);
}

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

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

struct PlasmaStatusRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaStatusRequestT NativeTableType;
  enum {
    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.Verify(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           verifier.EndTable();
  }
  PlasmaStatusRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaStatusRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaStatusRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaStatusRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaStatusRequest::VT_OBJECT_IDS, object_ids);
  }
  PlasmaStatusRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaStatusRequestBuilder &operator=(const PlasmaStatusRequestBuilder &);
  flatbuffers::Offset<PlasmaStatusRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    auto o = flatbuffers::Offset<PlasmaStatusRequest>(end);
    return o;
  }
};

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

inline flatbuffers::Offset<PlasmaStatusRequest> CreatePlasmaStatusRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr) {
  return CreatePlasmaStatusRequest(
      _fbb,
      object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0);
}

flatbuffers::Offset<PlasmaStatusRequest> CreatePlasmaStatusRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaStatusReplyT : public flatbuffers::NativeTable {
  typedef PlasmaStatusReply TableType;
  std::vector<std::string> object_ids;
  std::vector<ObjectStatus> status;
  PlasmaStatusReplyT() {
  }
};

struct PlasmaStatusReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaStatusReplyT NativeTableType;
  enum {
    VT_OBJECT_IDS = 4,
    VT_STATUS = 6
  };
  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> *status() const {
    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STATUS);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_IDS) &&
           verifier.Verify(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           VerifyOffset(verifier, VT_STATUS) &&
           verifier.Verify(status()) &&
           verifier.EndTable();
  }
  PlasmaStatusReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaStatusReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaStatusReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaStatusReplyBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaStatusReply::VT_OBJECT_IDS, object_ids);
  }
  void add_status(flatbuffers::Offset<flatbuffers::Vector<int32_t>> status) {
    fbb_.AddOffset(PlasmaStatusReply::VT_STATUS, status);
  }
  PlasmaStatusReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaStatusReplyBuilder &operator=(const PlasmaStatusReplyBuilder &);
  flatbuffers::Offset<PlasmaStatusReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<PlasmaStatusReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaStatusReply> CreatePlasmaStatusReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids = 0,
    flatbuffers::Offset<flatbuffers::Vector<int32_t>> status = 0) {
  PlasmaStatusReplyBuilder builder_(_fbb);
  builder_.add_status(status);
  builder_.add_object_ids(object_ids);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaStatusReply> CreatePlasmaStatusReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr,
    const std::vector<int32_t> *status = nullptr) {
  return CreatePlasmaStatusReply(
      _fbb,
      object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0,
      status ? _fbb.CreateVector<int32_t>(*status) : 0);
}

flatbuffers::Offset<PlasmaStatusReply> CreatePlasmaStatusReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusReplyT *_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;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaContainsRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaContainsRequestBuilder &operator=(const PlasmaContainsRequestBuilder &);
  flatbuffers::Offset<PlasmaContainsRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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) {
  return CreatePlasmaContainsRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0);
}

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;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaContainsReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaContainsReplyBuilder &operator=(const PlasmaContainsReplyBuilder &);
  flatbuffers::Offset<PlasmaContainsReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    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) {
  return CreatePlasmaContainsReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      has_object);
}

flatbuffers::Offset<PlasmaContainsReply> CreatePlasmaContainsReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaContainsReplyT *_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;
  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 {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  PlasmaConnectRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaConnectRequestBuilder &operator=(const PlasmaConnectRequestBuilder &);
  flatbuffers::Offset<PlasmaConnectRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 0);
    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;
  enum {
    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 {
  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);
  }
  PlasmaConnectReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaConnectReplyBuilder &operator=(const PlasmaConnectReplyBuilder &);
  flatbuffers::Offset<PlasmaConnectReply> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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;
  enum {
    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 {
  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);
  }
  PlasmaEvictRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaEvictRequestBuilder &operator=(const PlasmaEvictRequestBuilder &);
  flatbuffers::Offset<PlasmaEvictRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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;
  enum {
    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 {
  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);
  }
  PlasmaEvictReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaEvictReplyBuilder &operator=(const PlasmaEvictReplyBuilder &);
  flatbuffers::Offset<PlasmaEvictReply> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    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 PlasmaFetchRequestT : public flatbuffers::NativeTable {
  typedef PlasmaFetchRequest TableType;
  std::vector<std::string> object_ids;
  PlasmaFetchRequestT() {
  }
};

struct PlasmaFetchRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaFetchRequestT NativeTableType;
  enum {
    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.Verify(object_ids()) &&
           verifier.VerifyVectorOfStrings(object_ids()) &&
           verifier.EndTable();
  }
  PlasmaFetchRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaFetchRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaFetchRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaFetchRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaFetchRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_ids(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> object_ids) {
    fbb_.AddOffset(PlasmaFetchRequest::VT_OBJECT_IDS, object_ids);
  }
  PlasmaFetchRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaFetchRequestBuilder &operator=(const PlasmaFetchRequestBuilder &);
  flatbuffers::Offset<PlasmaFetchRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 1);
    auto o = flatbuffers::Offset<PlasmaFetchRequest>(end);
    return o;
  }
};

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

inline flatbuffers::Offset<PlasmaFetchRequest> CreatePlasmaFetchRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<flatbuffers::String>> *object_ids = nullptr) {
  return CreatePlasmaFetchRequest(
      _fbb,
      object_ids ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*object_ids) : 0);
}

flatbuffers::Offset<PlasmaFetchRequest> CreatePlasmaFetchRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaFetchRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ObjectRequestSpecT : public flatbuffers::NativeTable {
  typedef ObjectRequestSpec TableType;
  std::string object_id;
  int32_t type;
  ObjectRequestSpecT()
      : type(0) {
  }
};

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

struct ObjectRequestSpecBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(ObjectRequestSpec::VT_OBJECT_ID, object_id);
  }
  void add_type(int32_t type) {
    fbb_.AddElement<int32_t>(ObjectRequestSpec::VT_TYPE, type, 0);
  }
  ObjectRequestSpecBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ObjectRequestSpecBuilder &operator=(const ObjectRequestSpecBuilder &);
  flatbuffers::Offset<ObjectRequestSpec> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<ObjectRequestSpec>(end);
    return o;
  }
};

inline flatbuffers::Offset<ObjectRequestSpec> CreateObjectRequestSpec(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    int32_t type = 0) {
  ObjectRequestSpecBuilder builder_(_fbb);
  builder_.add_type(type);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<ObjectRequestSpec> CreateObjectRequestSpecDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    int32_t type = 0) {
  return CreateObjectRequestSpec(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      type);
}

flatbuffers::Offset<ObjectRequestSpec> CreateObjectRequestSpec(flatbuffers::FlatBufferBuilder &_fbb, const ObjectRequestSpecT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaWaitRequestT : public flatbuffers::NativeTable {
  typedef PlasmaWaitRequest TableType;
  std::vector<std::unique_ptr<ObjectRequestSpecT>> object_requests;
  int32_t num_ready_objects;
  int64_t timeout;
  PlasmaWaitRequestT()
      : num_ready_objects(0),
        timeout(0) {
  }
};

struct PlasmaWaitRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaWaitRequestT NativeTableType;
  enum {
    VT_OBJECT_REQUESTS = 4,
    VT_NUM_READY_OBJECTS = 6,
    VT_TIMEOUT = 8
  };
  const flatbuffers::Vector<flatbuffers::Offset<ObjectRequestSpec>> *object_requests() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ObjectRequestSpec>> *>(VT_OBJECT_REQUESTS);
  }
  int32_t num_ready_objects() const {
    return GetField<int32_t>(VT_NUM_READY_OBJECTS, 0);
  }
  int64_t timeout() const {
    return GetField<int64_t>(VT_TIMEOUT, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_REQUESTS) &&
           verifier.Verify(object_requests()) &&
           verifier.VerifyVectorOfTables(object_requests()) &&
           VerifyField<int32_t>(verifier, VT_NUM_READY_OBJECTS) &&
           VerifyField<int64_t>(verifier, VT_TIMEOUT) &&
           verifier.EndTable();
  }
  PlasmaWaitRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaWaitRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaWaitRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaWaitRequestBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_requests(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ObjectRequestSpec>>> object_requests) {
    fbb_.AddOffset(PlasmaWaitRequest::VT_OBJECT_REQUESTS, object_requests);
  }
  void add_num_ready_objects(int32_t num_ready_objects) {
    fbb_.AddElement<int32_t>(PlasmaWaitRequest::VT_NUM_READY_OBJECTS, num_ready_objects, 0);
  }
  void add_timeout(int64_t timeout) {
    fbb_.AddElement<int64_t>(PlasmaWaitRequest::VT_TIMEOUT, timeout, 0);
  }
  PlasmaWaitRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaWaitRequestBuilder &operator=(const PlasmaWaitRequestBuilder &);
  flatbuffers::Offset<PlasmaWaitRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 3);
    auto o = flatbuffers::Offset<PlasmaWaitRequest>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaWaitRequest> CreatePlasmaWaitRequest(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ObjectRequestSpec>>> object_requests = 0,
    int32_t num_ready_objects = 0,
    int64_t timeout = 0) {
  PlasmaWaitRequestBuilder builder_(_fbb);
  builder_.add_timeout(timeout);
  builder_.add_num_ready_objects(num_ready_objects);
  builder_.add_object_requests(object_requests);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaWaitRequest> CreatePlasmaWaitRequestDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<ObjectRequestSpec>> *object_requests = nullptr,
    int32_t num_ready_objects = 0,
    int64_t timeout = 0) {
  return CreatePlasmaWaitRequest(
      _fbb,
      object_requests ? _fbb.CreateVector<flatbuffers::Offset<ObjectRequestSpec>>(*object_requests) : 0,
      num_ready_objects,
      timeout);
}

flatbuffers::Offset<PlasmaWaitRequest> CreatePlasmaWaitRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct ObjectReplyT : public flatbuffers::NativeTable {
  typedef ObjectReply TableType;
  std::string object_id;
  int32_t status;
  ObjectReplyT()
      : status(0) {
  }
};

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

struct ObjectReplyBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_id(flatbuffers::Offset<flatbuffers::String> object_id) {
    fbb_.AddOffset(ObjectReply::VT_OBJECT_ID, object_id);
  }
  void add_status(int32_t status) {
    fbb_.AddElement<int32_t>(ObjectReply::VT_STATUS, status, 0);
  }
  ObjectReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ObjectReplyBuilder &operator=(const ObjectReplyBuilder &);
  flatbuffers::Offset<ObjectReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<ObjectReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<ObjectReply> CreateObjectReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::String> object_id = 0,
    int32_t status = 0) {
  ObjectReplyBuilder builder_(_fbb);
  builder_.add_status(status);
  builder_.add_object_id(object_id);
  return builder_.Finish();
}

inline flatbuffers::Offset<ObjectReply> CreateObjectReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const char *object_id = nullptr,
    int32_t status = 0) {
  return CreateObjectReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      status);
}

flatbuffers::Offset<ObjectReply> CreateObjectReply(flatbuffers::FlatBufferBuilder &_fbb, const ObjectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);

struct PlasmaWaitReplyT : public flatbuffers::NativeTable {
  typedef PlasmaWaitReply TableType;
  std::vector<std::unique_ptr<ObjectReplyT>> object_requests;
  int32_t num_ready_objects;
  PlasmaWaitReplyT()
      : num_ready_objects(0) {
  }
};

struct PlasmaWaitReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
  typedef PlasmaWaitReplyT NativeTableType;
  enum {
    VT_OBJECT_REQUESTS = 4,
    VT_NUM_READY_OBJECTS = 6
  };
  const flatbuffers::Vector<flatbuffers::Offset<ObjectReply>> *object_requests() const {
    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<ObjectReply>> *>(VT_OBJECT_REQUESTS);
  }
  int32_t num_ready_objects() const {
    return GetField<int32_t>(VT_NUM_READY_OBJECTS, 0);
  }
  bool Verify(flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_OBJECT_REQUESTS) &&
           verifier.Verify(object_requests()) &&
           verifier.VerifyVectorOfTables(object_requests()) &&
           VerifyField<int32_t>(verifier, VT_NUM_READY_OBJECTS) &&
           verifier.EndTable();
  }
  PlasmaWaitReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  void UnPackTo(PlasmaWaitReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
  static flatbuffers::Offset<PlasmaWaitReply> Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};

struct PlasmaWaitReplyBuilder {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  void add_object_requests(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ObjectReply>>> object_requests) {
    fbb_.AddOffset(PlasmaWaitReply::VT_OBJECT_REQUESTS, object_requests);
  }
  void add_num_ready_objects(int32_t num_ready_objects) {
    fbb_.AddElement<int32_t>(PlasmaWaitReply::VT_NUM_READY_OBJECTS, num_ready_objects, 0);
  }
  PlasmaWaitReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaWaitReplyBuilder &operator=(const PlasmaWaitReplyBuilder &);
  flatbuffers::Offset<PlasmaWaitReply> Finish() {
    const auto end = fbb_.EndTable(start_, 2);
    auto o = flatbuffers::Offset<PlasmaWaitReply>(end);
    return o;
  }
};

inline flatbuffers::Offset<PlasmaWaitReply> CreatePlasmaWaitReply(
    flatbuffers::FlatBufferBuilder &_fbb,
    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<ObjectReply>>> object_requests = 0,
    int32_t num_ready_objects = 0) {
  PlasmaWaitReplyBuilder builder_(_fbb);
  builder_.add_num_ready_objects(num_ready_objects);
  builder_.add_object_requests(object_requests);
  return builder_.Finish();
}

inline flatbuffers::Offset<PlasmaWaitReply> CreatePlasmaWaitReplyDirect(
    flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<flatbuffers::Offset<ObjectReply>> *object_requests = nullptr,
    int32_t num_ready_objects = 0) {
  return CreatePlasmaWaitReply(
      _fbb,
      object_requests ? _fbb.CreateVector<flatbuffers::Offset<ObjectReply>>(*object_requests) : 0,
      num_ready_objects);
}

flatbuffers::Offset<PlasmaWaitReply> CreatePlasmaWaitReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitReplyT *_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;
  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 {
  flatbuffers::FlatBufferBuilder &fbb_;
  flatbuffers::uoffset_t start_;
  PlasmaSubscribeRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaSubscribeRequestBuilder &operator=(const PlasmaSubscribeRequestBuilder &);
  flatbuffers::Offset<PlasmaSubscribeRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 0);
    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 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;
  enum {
    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.Verify(object_id()) &&
           VerifyOffset(verifier, VT_ADDRESS) &&
           verifier.Verify(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 {
  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);
  }
  PlasmaDataRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaDataRequestBuilder &operator=(const PlasmaDataRequestBuilder &);
  flatbuffers::Offset<PlasmaDataRequest> Finish() {
    const auto end = fbb_.EndTable(start_, 3);
    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) {
  return CreatePlasmaDataRequest(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      address ? _fbb.CreateString(address) : 0,
      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;
  enum {
    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.Verify(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 {
  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);
  }
  PlasmaDataReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  PlasmaDataReplyBuilder &operator=(const PlasmaDataReplyBuilder &);
  flatbuffers::Offset<PlasmaDataReply> Finish() {
    const auto end = fbb_.EndTable(start_, 3);
    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) {
  return CreatePlasmaDataReply(
      _fbb,
      object_id ? _fbb.CreateString(object_id) : 0,
      object_size,
      metadata_size);
}

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

inline PlasmaCreateRequestT *PlasmaCreateRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaCreateRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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 = 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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _data_size = _o->data_size;
  auto _metadata_size = _o->metadata_size;
  auto _device_num = _o->device_num;
  return CreatePlasmaCreateRequest(
      _fbb,
      _object_id,
      _data_size,
      _metadata_size,
      _device_num);
}

inline CudaHandleT *CudaHandle::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new CudaHandleT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _handle = _o->handle.size() ? _fbb.CreateVector(_o->handle) : 0;
  return CreateCudaHandle(
      _fbb,
      _handle);
}

inline PlasmaCreateReplyT *PlasmaCreateReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaCreateReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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<PlasmaObjectSpec>(new 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<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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  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 CreatePlasmaCreateReply(
      _fbb,
      _object_id,
      _plasma_object,
      _error,
      _store_fd,
      _mmap_size,
      _ipc_handle);
}

inline PlasmaAbortRequestT *PlasmaAbortRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaAbortRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  return CreatePlasmaAbortRequest(
      _fbb,
      _object_id);
}

inline PlasmaAbortReplyT *PlasmaAbortReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaAbortReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  return CreatePlasmaAbortReply(
      _fbb,
      _object_id);
}

inline PlasmaSealRequestT *PlasmaSealRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaSealRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _digest = _o->digest.size() ? _fbb.CreateString(_o->digest) : 0;
  return CreatePlasmaSealRequest(
      _fbb,
      _object_id,
      _digest);
}

inline PlasmaSealReplyT *PlasmaSealReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaSealReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _error = _o->error;
  return CreatePlasmaSealReply(
      _fbb,
      _object_id,
      _error);
}

inline PlasmaGetRequestT *PlasmaGetRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaGetRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  auto _timeout_ms = _o->timeout_ms;
  return CreatePlasmaGetRequest(
      _fbb,
      _object_ids,
      _timeout_ms);
}

inline PlasmaGetReplyT *PlasmaGetReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaGetReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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<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;
  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<CudaHandle>>(_o->handles.size(), [&](size_t i) { return CreateCudaHandle(_fbb, _o->handles[i].get(), _rehasher); }) : 0;
  return CreatePlasmaGetReply(
      _fbb,
      _object_ids,
      _plasma_objects,
      _store_fds,
      _mmap_sizes,
      _handles);
}

inline PlasmaReleaseRequestT *PlasmaReleaseRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaReleaseRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  return CreatePlasmaReleaseRequest(
      _fbb,
      _object_id);
}

inline PlasmaReleaseReplyT *PlasmaReleaseReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaReleaseReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _error = _o->error;
  return CreatePlasmaReleaseReply(
      _fbb,
      _object_id,
      _error);
}

inline PlasmaDeleteRequestT *PlasmaDeleteRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaDeleteRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaDeleteRequest::UnPackTo(PlasmaDeleteRequestT *_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<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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  return CreatePlasmaDeleteRequest(
      _fbb,
      _object_id);
}

inline PlasmaDeleteReplyT *PlasmaDeleteReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaDeleteReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaDeleteReply::UnPackTo(PlasmaDeleteReplyT *_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<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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _error = _o->error;
  return CreatePlasmaDeleteReply(
      _fbb,
      _object_id,
      _error);
}

inline PlasmaStatusRequestT *PlasmaStatusRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaStatusRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaStatusRequest::UnPackTo(PlasmaStatusRequestT *_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<PlasmaStatusRequest> PlasmaStatusRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaStatusRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaStatusRequest> CreatePlasmaStatusRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  return CreatePlasmaStatusRequest(
      _fbb,
      _object_ids);
}

inline PlasmaStatusReplyT *PlasmaStatusReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaStatusReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaStatusReply::UnPackTo(PlasmaStatusReplyT *_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 = status(); if (_e) { _o->status.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->status[_i] = (ObjectStatus)_e->Get(_i); } } };
}

inline flatbuffers::Offset<PlasmaStatusReply> PlasmaStatusReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaStatusReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaStatusReply> CreatePlasmaStatusReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaStatusReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  auto _status = _o->status.size() ? _fbb.CreateVector((const int32_t*)_o->status.data(), _o->status.size()) : 0;
  return CreatePlasmaStatusReply(
      _fbb,
      _object_ids,
      _status);
}

inline PlasmaContainsRequestT *PlasmaContainsRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaContainsRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  return CreatePlasmaContainsRequest(
      _fbb,
      _object_id);
}

inline PlasmaContainsReplyT *PlasmaContainsReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaContainsReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _has_object = _o->has_object;
  return CreatePlasmaContainsReply(
      _fbb,
      _object_id,
      _has_object);
}

inline PlasmaConnectRequestT *PlasmaConnectRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaConnectRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  return CreatePlasmaConnectRequest(
      _fbb);
}

inline PlasmaConnectReplyT *PlasmaConnectReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaConnectReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _memory_capacity = _o->memory_capacity;
  return CreatePlasmaConnectReply(
      _fbb,
      _memory_capacity);
}

inline PlasmaEvictRequestT *PlasmaEvictRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaEvictRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _num_bytes = _o->num_bytes;
  return CreatePlasmaEvictRequest(
      _fbb,
      _num_bytes);
}

inline PlasmaEvictReplyT *PlasmaEvictReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaEvictReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _num_bytes = _o->num_bytes;
  return CreatePlasmaEvictReply(
      _fbb,
      _num_bytes);
}

inline PlasmaFetchRequestT *PlasmaFetchRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaFetchRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaFetchRequest::UnPackTo(PlasmaFetchRequestT *_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<PlasmaFetchRequest> PlasmaFetchRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaFetchRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaFetchRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaFetchRequest> CreatePlasmaFetchRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaFetchRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_ids = _o->object_ids.size() ? _fbb.CreateVectorOfStrings(_o->object_ids) : 0;
  return CreatePlasmaFetchRequest(
      _fbb,
      _object_ids);
}

inline ObjectRequestSpecT *ObjectRequestSpec::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new ObjectRequestSpecT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void ObjectRequestSpec::UnPackTo(ObjectRequestSpecT *_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 = type(); _o->type = _e; };
}

inline flatbuffers::Offset<ObjectRequestSpec> ObjectRequestSpec::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ObjectRequestSpecT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateObjectRequestSpec(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<ObjectRequestSpec> CreateObjectRequestSpec(flatbuffers::FlatBufferBuilder &_fbb, const ObjectRequestSpecT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _type = _o->type;
  return CreateObjectRequestSpec(
      _fbb,
      _object_id,
      _type);
}

inline PlasmaWaitRequestT *PlasmaWaitRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaWaitRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaWaitRequest::UnPackTo(PlasmaWaitRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_requests(); if (_e) { _o->object_requests.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_requests[_i] = std::unique_ptr<ObjectRequestSpecT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = num_ready_objects(); _o->num_ready_objects = _e; };
  { auto _e = timeout(); _o->timeout = _e; };
}

inline flatbuffers::Offset<PlasmaWaitRequest> PlasmaWaitRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaWaitRequest(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaWaitRequest> CreatePlasmaWaitRequest(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_requests = _o->object_requests.size() ? _fbb.CreateVector<flatbuffers::Offset<ObjectRequestSpec>>(_o->object_requests.size(), [&](size_t i) { return CreateObjectRequestSpec(_fbb, _o->object_requests[i].get(), _rehasher); }) : 0;
  auto _num_ready_objects = _o->num_ready_objects;
  auto _timeout = _o->timeout;
  return CreatePlasmaWaitRequest(
      _fbb,
      _object_requests,
      _num_ready_objects,
      _timeout);
}

inline ObjectReplyT *ObjectReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new ObjectReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void ObjectReply::UnPackTo(ObjectReplyT *_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 = status(); _o->status = _e; };
}

inline flatbuffers::Offset<ObjectReply> ObjectReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ObjectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreateObjectReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<ObjectReply> CreateObjectReply(flatbuffers::FlatBufferBuilder &_fbb, const ObjectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _status = _o->status;
  return CreateObjectReply(
      _fbb,
      _object_id,
      _status);
}

inline PlasmaWaitReplyT *PlasmaWaitReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaWaitReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

inline void PlasmaWaitReply::UnPackTo(PlasmaWaitReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const {
  (void)_o;
  (void)_resolver;
  { auto _e = object_requests(); if (_e) { _o->object_requests.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->object_requests[_i] = std::unique_ptr<ObjectReplyT>(_e->Get(_i)->UnPack(_resolver)); } } };
  { auto _e = num_ready_objects(); _o->num_ready_objects = _e; };
}

inline flatbuffers::Offset<PlasmaWaitReply> PlasmaWaitReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
  return CreatePlasmaWaitReply(_fbb, _o, _rehasher);
}

inline flatbuffers::Offset<PlasmaWaitReply> CreatePlasmaWaitReply(flatbuffers::FlatBufferBuilder &_fbb, const PlasmaWaitReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
  (void)_rehasher;
  (void)_o;
  auto _object_requests = _o->object_requests.size() ? _fbb.CreateVector<flatbuffers::Offset<ObjectReply>>(_o->object_requests.size(), [&](size_t i) { return CreateObjectReply(_fbb, _o->object_requests[i].get(), _rehasher); }) : 0;
  auto _num_ready_objects = _o->num_ready_objects;
  return CreatePlasmaWaitReply(
      _fbb,
      _object_requests,
      _num_ready_objects);
}

inline PlasmaSubscribeRequestT *PlasmaSubscribeRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaSubscribeRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  return CreatePlasmaSubscribeRequest(
      _fbb);
}

inline PlasmaDataRequestT *PlasmaDataRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaDataRequestT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _address = _o->address.size() ? _fbb.CreateString(_o->address) : 0;
  auto _port = _o->port;
  return CreatePlasmaDataRequest(
      _fbb,
      _object_id,
      _address,
      _port);
}

inline PlasmaDataReplyT *PlasmaDataReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
  auto _o = new PlasmaDataReplyT();
  UnPackTo(_o, _resolver);
  return _o;
}

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;
  auto _object_id = _o->object_id.size() ? _fbb.CreateString(_o->object_id) : 0;
  auto _object_size = _o->object_size;
  auto _metadata_size = _o->metadata_size;
  return CreatePlasmaDataReply(
      _fbb,
      _object_id,
      _object_size,
      _metadata_size);
}

#endif  // FLATBUFFERS_GENERATED_PLASMA_H_
