// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: tensorflow/core/data/service/journal.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3018000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3018001 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/unknown_field_set.h>
#include "tensorflow/core/data/service/common.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[15]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
namespace tensorflow {
namespace data {
class AcquireJobClientUpdate;
struct AcquireJobClientUpdateDefaultTypeInternal;
extern AcquireJobClientUpdateDefaultTypeInternal _AcquireJobClientUpdate_default_instance_;
class ClientHeartbeatUpdate;
struct ClientHeartbeatUpdateDefaultTypeInternal;
extern ClientHeartbeatUpdateDefaultTypeInternal _ClientHeartbeatUpdate_default_instance_;
class CreateJobUpdate;
struct CreateJobUpdateDefaultTypeInternal;
extern CreateJobUpdateDefaultTypeInternal _CreateJobUpdate_default_instance_;
class CreatePendingTaskUpdate;
struct CreatePendingTaskUpdateDefaultTypeInternal;
extern CreatePendingTaskUpdateDefaultTypeInternal _CreatePendingTaskUpdate_default_instance_;
class CreateTaskUpdate;
struct CreateTaskUpdateDefaultTypeInternal;
extern CreateTaskUpdateDefaultTypeInternal _CreateTaskUpdate_default_instance_;
class FinishTaskUpdate;
struct FinishTaskUpdateDefaultTypeInternal;
extern FinishTaskUpdateDefaultTypeInternal _FinishTaskUpdate_default_instance_;
class GarbageCollectJobUpdate;
struct GarbageCollectJobUpdateDefaultTypeInternal;
extern GarbageCollectJobUpdateDefaultTypeInternal _GarbageCollectJobUpdate_default_instance_;
class NamedJobKeyDef;
struct NamedJobKeyDefDefaultTypeInternal;
extern NamedJobKeyDefDefaultTypeInternal _NamedJobKeyDef_default_instance_;
class ProduceSplitUpdate;
struct ProduceSplitUpdateDefaultTypeInternal;
extern ProduceSplitUpdateDefaultTypeInternal _ProduceSplitUpdate_default_instance_;
class RegisterDatasetUpdate;
struct RegisterDatasetUpdateDefaultTypeInternal;
extern RegisterDatasetUpdateDefaultTypeInternal _RegisterDatasetUpdate_default_instance_;
class RegisterWorkerUpdate;
struct RegisterWorkerUpdateDefaultTypeInternal;
extern RegisterWorkerUpdateDefaultTypeInternal _RegisterWorkerUpdate_default_instance_;
class ReleaseJobClientUpdate;
struct ReleaseJobClientUpdateDefaultTypeInternal;
extern ReleaseJobClientUpdateDefaultTypeInternal _ReleaseJobClientUpdate_default_instance_;
class RemoveTaskUpdate;
struct RemoveTaskUpdateDefaultTypeInternal;
extern RemoveTaskUpdateDefaultTypeInternal _RemoveTaskUpdate_default_instance_;
class TaskRejected;
struct TaskRejectedDefaultTypeInternal;
extern TaskRejectedDefaultTypeInternal _TaskRejected_default_instance_;
class Update;
struct UpdateDefaultTypeInternal;
extern UpdateDefaultTypeInternal _Update_default_instance_;
}  // namespace data
}  // namespace tensorflow
PROTOBUF_NAMESPACE_OPEN
template<> ::tensorflow::data::AcquireJobClientUpdate* Arena::CreateMaybeMessage<::tensorflow::data::AcquireJobClientUpdate>(Arena*);
template<> ::tensorflow::data::ClientHeartbeatUpdate* Arena::CreateMaybeMessage<::tensorflow::data::ClientHeartbeatUpdate>(Arena*);
template<> ::tensorflow::data::CreateJobUpdate* Arena::CreateMaybeMessage<::tensorflow::data::CreateJobUpdate>(Arena*);
template<> ::tensorflow::data::CreatePendingTaskUpdate* Arena::CreateMaybeMessage<::tensorflow::data::CreatePendingTaskUpdate>(Arena*);
template<> ::tensorflow::data::CreateTaskUpdate* Arena::CreateMaybeMessage<::tensorflow::data::CreateTaskUpdate>(Arena*);
template<> ::tensorflow::data::FinishTaskUpdate* Arena::CreateMaybeMessage<::tensorflow::data::FinishTaskUpdate>(Arena*);
template<> ::tensorflow::data::GarbageCollectJobUpdate* Arena::CreateMaybeMessage<::tensorflow::data::GarbageCollectJobUpdate>(Arena*);
template<> ::tensorflow::data::NamedJobKeyDef* Arena::CreateMaybeMessage<::tensorflow::data::NamedJobKeyDef>(Arena*);
template<> ::tensorflow::data::ProduceSplitUpdate* Arena::CreateMaybeMessage<::tensorflow::data::ProduceSplitUpdate>(Arena*);
template<> ::tensorflow::data::RegisterDatasetUpdate* Arena::CreateMaybeMessage<::tensorflow::data::RegisterDatasetUpdate>(Arena*);
template<> ::tensorflow::data::RegisterWorkerUpdate* Arena::CreateMaybeMessage<::tensorflow::data::RegisterWorkerUpdate>(Arena*);
template<> ::tensorflow::data::ReleaseJobClientUpdate* Arena::CreateMaybeMessage<::tensorflow::data::ReleaseJobClientUpdate>(Arena*);
template<> ::tensorflow::data::RemoveTaskUpdate* Arena::CreateMaybeMessage<::tensorflow::data::RemoveTaskUpdate>(Arena*);
template<> ::tensorflow::data::TaskRejected* Arena::CreateMaybeMessage<::tensorflow::data::TaskRejected>(Arena*);
template<> ::tensorflow::data::Update* Arena::CreateMaybeMessage<::tensorflow::data::Update>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace tensorflow {
namespace data {

// ===================================================================

class Update final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.Update) */ {
 public:
  inline Update() : Update(nullptr) {}
  ~Update() override;
  explicit constexpr Update(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Update(const Update& from);
  Update(Update&& from) noexcept
    : Update() {
    *this = ::std::move(from);
  }

  inline Update& operator=(const Update& from) {
    CopyFrom(from);
    return *this;
  }
  inline Update& operator=(Update&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const Update& default_instance() {
    return *internal_default_instance();
  }
  enum UpdateTypeCase {
    kRegisterDataset = 1,
    kRegisterWorker = 5,
    kCreateJob = 2,
    kProduceSplit = 8,
    kAcquireJobClient = 6,
    kReleaseJobClient = 7,
    kGarbageCollectJob = 12,
    kRemoveTask = 11,
    kCreatePendingTask = 9,
    kClientHeartbeat = 10,
    kCreateTask = 3,
    kFinishTask = 4,
    UPDATE_TYPE_NOT_SET = 0,
  };

  static inline const Update* internal_default_instance() {
    return reinterpret_cast<const Update*>(
               &_Update_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Update& a, Update& b) {
    a.Swap(&b);
  }
  inline void Swap(Update* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Update* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Update* New() const final {
    return new Update();
  }

  Update* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Update>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Update& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Update& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(Update* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.Update";
  }
  protected:
  explicit Update(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kRegisterDatasetFieldNumber = 1,
    kRegisterWorkerFieldNumber = 5,
    kCreateJobFieldNumber = 2,
    kProduceSplitFieldNumber = 8,
    kAcquireJobClientFieldNumber = 6,
    kReleaseJobClientFieldNumber = 7,
    kGarbageCollectJobFieldNumber = 12,
    kRemoveTaskFieldNumber = 11,
    kCreatePendingTaskFieldNumber = 9,
    kClientHeartbeatFieldNumber = 10,
    kCreateTaskFieldNumber = 3,
    kFinishTaskFieldNumber = 4,
  };
  // .tensorflow.data.RegisterDatasetUpdate register_dataset = 1;
  bool has_register_dataset() const;
  private:
  bool _internal_has_register_dataset() const;
  public:
  void clear_register_dataset();
  const ::tensorflow::data::RegisterDatasetUpdate& register_dataset() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::RegisterDatasetUpdate* release_register_dataset();
  ::tensorflow::data::RegisterDatasetUpdate* mutable_register_dataset();
  void set_allocated_register_dataset(::tensorflow::data::RegisterDatasetUpdate* register_dataset);
  private:
  const ::tensorflow::data::RegisterDatasetUpdate& _internal_register_dataset() const;
  ::tensorflow::data::RegisterDatasetUpdate* _internal_mutable_register_dataset();
  public:
  void unsafe_arena_set_allocated_register_dataset(
      ::tensorflow::data::RegisterDatasetUpdate* register_dataset);
  ::tensorflow::data::RegisterDatasetUpdate* unsafe_arena_release_register_dataset();

  // .tensorflow.data.RegisterWorkerUpdate register_worker = 5;
  bool has_register_worker() const;
  private:
  bool _internal_has_register_worker() const;
  public:
  void clear_register_worker();
  const ::tensorflow::data::RegisterWorkerUpdate& register_worker() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::RegisterWorkerUpdate* release_register_worker();
  ::tensorflow::data::RegisterWorkerUpdate* mutable_register_worker();
  void set_allocated_register_worker(::tensorflow::data::RegisterWorkerUpdate* register_worker);
  private:
  const ::tensorflow::data::RegisterWorkerUpdate& _internal_register_worker() const;
  ::tensorflow::data::RegisterWorkerUpdate* _internal_mutable_register_worker();
  public:
  void unsafe_arena_set_allocated_register_worker(
      ::tensorflow::data::RegisterWorkerUpdate* register_worker);
  ::tensorflow::data::RegisterWorkerUpdate* unsafe_arena_release_register_worker();

  // .tensorflow.data.CreateJobUpdate create_job = 2;
  bool has_create_job() const;
  private:
  bool _internal_has_create_job() const;
  public:
  void clear_create_job();
  const ::tensorflow::data::CreateJobUpdate& create_job() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::CreateJobUpdate* release_create_job();
  ::tensorflow::data::CreateJobUpdate* mutable_create_job();
  void set_allocated_create_job(::tensorflow::data::CreateJobUpdate* create_job);
  private:
  const ::tensorflow::data::CreateJobUpdate& _internal_create_job() const;
  ::tensorflow::data::CreateJobUpdate* _internal_mutable_create_job();
  public:
  void unsafe_arena_set_allocated_create_job(
      ::tensorflow::data::CreateJobUpdate* create_job);
  ::tensorflow::data::CreateJobUpdate* unsafe_arena_release_create_job();

  // .tensorflow.data.ProduceSplitUpdate produce_split = 8;
  bool has_produce_split() const;
  private:
  bool _internal_has_produce_split() const;
  public:
  void clear_produce_split();
  const ::tensorflow::data::ProduceSplitUpdate& produce_split() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::ProduceSplitUpdate* release_produce_split();
  ::tensorflow::data::ProduceSplitUpdate* mutable_produce_split();
  void set_allocated_produce_split(::tensorflow::data::ProduceSplitUpdate* produce_split);
  private:
  const ::tensorflow::data::ProduceSplitUpdate& _internal_produce_split() const;
  ::tensorflow::data::ProduceSplitUpdate* _internal_mutable_produce_split();
  public:
  void unsafe_arena_set_allocated_produce_split(
      ::tensorflow::data::ProduceSplitUpdate* produce_split);
  ::tensorflow::data::ProduceSplitUpdate* unsafe_arena_release_produce_split();

  // .tensorflow.data.AcquireJobClientUpdate acquire_job_client = 6;
  bool has_acquire_job_client() const;
  private:
  bool _internal_has_acquire_job_client() const;
  public:
  void clear_acquire_job_client();
  const ::tensorflow::data::AcquireJobClientUpdate& acquire_job_client() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::AcquireJobClientUpdate* release_acquire_job_client();
  ::tensorflow::data::AcquireJobClientUpdate* mutable_acquire_job_client();
  void set_allocated_acquire_job_client(::tensorflow::data::AcquireJobClientUpdate* acquire_job_client);
  private:
  const ::tensorflow::data::AcquireJobClientUpdate& _internal_acquire_job_client() const;
  ::tensorflow::data::AcquireJobClientUpdate* _internal_mutable_acquire_job_client();
  public:
  void unsafe_arena_set_allocated_acquire_job_client(
      ::tensorflow::data::AcquireJobClientUpdate* acquire_job_client);
  ::tensorflow::data::AcquireJobClientUpdate* unsafe_arena_release_acquire_job_client();

  // .tensorflow.data.ReleaseJobClientUpdate release_job_client = 7;
  bool has_release_job_client() const;
  private:
  bool _internal_has_release_job_client() const;
  public:
  void clear_release_job_client();
  const ::tensorflow::data::ReleaseJobClientUpdate& release_job_client() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::ReleaseJobClientUpdate* release_release_job_client();
  ::tensorflow::data::ReleaseJobClientUpdate* mutable_release_job_client();
  void set_allocated_release_job_client(::tensorflow::data::ReleaseJobClientUpdate* release_job_client);
  private:
  const ::tensorflow::data::ReleaseJobClientUpdate& _internal_release_job_client() const;
  ::tensorflow::data::ReleaseJobClientUpdate* _internal_mutable_release_job_client();
  public:
  void unsafe_arena_set_allocated_release_job_client(
      ::tensorflow::data::ReleaseJobClientUpdate* release_job_client);
  ::tensorflow::data::ReleaseJobClientUpdate* unsafe_arena_release_release_job_client();

  // .tensorflow.data.GarbageCollectJobUpdate garbage_collect_job = 12;
  bool has_garbage_collect_job() const;
  private:
  bool _internal_has_garbage_collect_job() const;
  public:
  void clear_garbage_collect_job();
  const ::tensorflow::data::GarbageCollectJobUpdate& garbage_collect_job() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::GarbageCollectJobUpdate* release_garbage_collect_job();
  ::tensorflow::data::GarbageCollectJobUpdate* mutable_garbage_collect_job();
  void set_allocated_garbage_collect_job(::tensorflow::data::GarbageCollectJobUpdate* garbage_collect_job);
  private:
  const ::tensorflow::data::GarbageCollectJobUpdate& _internal_garbage_collect_job() const;
  ::tensorflow::data::GarbageCollectJobUpdate* _internal_mutable_garbage_collect_job();
  public:
  void unsafe_arena_set_allocated_garbage_collect_job(
      ::tensorflow::data::GarbageCollectJobUpdate* garbage_collect_job);
  ::tensorflow::data::GarbageCollectJobUpdate* unsafe_arena_release_garbage_collect_job();

  // .tensorflow.data.RemoveTaskUpdate remove_task = 11;
  bool has_remove_task() const;
  private:
  bool _internal_has_remove_task() const;
  public:
  void clear_remove_task();
  const ::tensorflow::data::RemoveTaskUpdate& remove_task() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::RemoveTaskUpdate* release_remove_task();
  ::tensorflow::data::RemoveTaskUpdate* mutable_remove_task();
  void set_allocated_remove_task(::tensorflow::data::RemoveTaskUpdate* remove_task);
  private:
  const ::tensorflow::data::RemoveTaskUpdate& _internal_remove_task() const;
  ::tensorflow::data::RemoveTaskUpdate* _internal_mutable_remove_task();
  public:
  void unsafe_arena_set_allocated_remove_task(
      ::tensorflow::data::RemoveTaskUpdate* remove_task);
  ::tensorflow::data::RemoveTaskUpdate* unsafe_arena_release_remove_task();

  // .tensorflow.data.CreatePendingTaskUpdate create_pending_task = 9;
  bool has_create_pending_task() const;
  private:
  bool _internal_has_create_pending_task() const;
  public:
  void clear_create_pending_task();
  const ::tensorflow::data::CreatePendingTaskUpdate& create_pending_task() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::CreatePendingTaskUpdate* release_create_pending_task();
  ::tensorflow::data::CreatePendingTaskUpdate* mutable_create_pending_task();
  void set_allocated_create_pending_task(::tensorflow::data::CreatePendingTaskUpdate* create_pending_task);
  private:
  const ::tensorflow::data::CreatePendingTaskUpdate& _internal_create_pending_task() const;
  ::tensorflow::data::CreatePendingTaskUpdate* _internal_mutable_create_pending_task();
  public:
  void unsafe_arena_set_allocated_create_pending_task(
      ::tensorflow::data::CreatePendingTaskUpdate* create_pending_task);
  ::tensorflow::data::CreatePendingTaskUpdate* unsafe_arena_release_create_pending_task();

  // .tensorflow.data.ClientHeartbeatUpdate client_heartbeat = 10;
  bool has_client_heartbeat() const;
  private:
  bool _internal_has_client_heartbeat() const;
  public:
  void clear_client_heartbeat();
  const ::tensorflow::data::ClientHeartbeatUpdate& client_heartbeat() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::ClientHeartbeatUpdate* release_client_heartbeat();
  ::tensorflow::data::ClientHeartbeatUpdate* mutable_client_heartbeat();
  void set_allocated_client_heartbeat(::tensorflow::data::ClientHeartbeatUpdate* client_heartbeat);
  private:
  const ::tensorflow::data::ClientHeartbeatUpdate& _internal_client_heartbeat() const;
  ::tensorflow::data::ClientHeartbeatUpdate* _internal_mutable_client_heartbeat();
  public:
  void unsafe_arena_set_allocated_client_heartbeat(
      ::tensorflow::data::ClientHeartbeatUpdate* client_heartbeat);
  ::tensorflow::data::ClientHeartbeatUpdate* unsafe_arena_release_client_heartbeat();

  // .tensorflow.data.CreateTaskUpdate create_task = 3;
  bool has_create_task() const;
  private:
  bool _internal_has_create_task() const;
  public:
  void clear_create_task();
  const ::tensorflow::data::CreateTaskUpdate& create_task() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::CreateTaskUpdate* release_create_task();
  ::tensorflow::data::CreateTaskUpdate* mutable_create_task();
  void set_allocated_create_task(::tensorflow::data::CreateTaskUpdate* create_task);
  private:
  const ::tensorflow::data::CreateTaskUpdate& _internal_create_task() const;
  ::tensorflow::data::CreateTaskUpdate* _internal_mutable_create_task();
  public:
  void unsafe_arena_set_allocated_create_task(
      ::tensorflow::data::CreateTaskUpdate* create_task);
  ::tensorflow::data::CreateTaskUpdate* unsafe_arena_release_create_task();

  // .tensorflow.data.FinishTaskUpdate finish_task = 4;
  bool has_finish_task() const;
  private:
  bool _internal_has_finish_task() const;
  public:
  void clear_finish_task();
  const ::tensorflow::data::FinishTaskUpdate& finish_task() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::FinishTaskUpdate* release_finish_task();
  ::tensorflow::data::FinishTaskUpdate* mutable_finish_task();
  void set_allocated_finish_task(::tensorflow::data::FinishTaskUpdate* finish_task);
  private:
  const ::tensorflow::data::FinishTaskUpdate& _internal_finish_task() const;
  ::tensorflow::data::FinishTaskUpdate* _internal_mutable_finish_task();
  public:
  void unsafe_arena_set_allocated_finish_task(
      ::tensorflow::data::FinishTaskUpdate* finish_task);
  ::tensorflow::data::FinishTaskUpdate* unsafe_arena_release_finish_task();

  void clear_update_type();
  UpdateTypeCase update_type_case() const;
  // @@protoc_insertion_point(class_scope:tensorflow.data.Update)
 private:
  class _Internal;
  void set_has_register_dataset();
  void set_has_register_worker();
  void set_has_create_job();
  void set_has_produce_split();
  void set_has_acquire_job_client();
  void set_has_release_job_client();
  void set_has_garbage_collect_job();
  void set_has_remove_task();
  void set_has_create_pending_task();
  void set_has_client_heartbeat();
  void set_has_create_task();
  void set_has_finish_task();

  inline bool has_update_type() const;
  inline void clear_has_update_type();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  union UpdateTypeUnion {
    constexpr UpdateTypeUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::tensorflow::data::RegisterDatasetUpdate* register_dataset_;
    ::tensorflow::data::RegisterWorkerUpdate* register_worker_;
    ::tensorflow::data::CreateJobUpdate* create_job_;
    ::tensorflow::data::ProduceSplitUpdate* produce_split_;
    ::tensorflow::data::AcquireJobClientUpdate* acquire_job_client_;
    ::tensorflow::data::ReleaseJobClientUpdate* release_job_client_;
    ::tensorflow::data::GarbageCollectJobUpdate* garbage_collect_job_;
    ::tensorflow::data::RemoveTaskUpdate* remove_task_;
    ::tensorflow::data::CreatePendingTaskUpdate* create_pending_task_;
    ::tensorflow::data::ClientHeartbeatUpdate* client_heartbeat_;
    ::tensorflow::data::CreateTaskUpdate* create_task_;
    ::tensorflow::data::FinishTaskUpdate* finish_task_;
  } update_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class RegisterDatasetUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.RegisterDatasetUpdate) */ {
 public:
  inline RegisterDatasetUpdate() : RegisterDatasetUpdate(nullptr) {}
  ~RegisterDatasetUpdate() override;
  explicit constexpr RegisterDatasetUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RegisterDatasetUpdate(const RegisterDatasetUpdate& from);
  RegisterDatasetUpdate(RegisterDatasetUpdate&& from) noexcept
    : RegisterDatasetUpdate() {
    *this = ::std::move(from);
  }

  inline RegisterDatasetUpdate& operator=(const RegisterDatasetUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline RegisterDatasetUpdate& operator=(RegisterDatasetUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RegisterDatasetUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const RegisterDatasetUpdate* internal_default_instance() {
    return reinterpret_cast<const RegisterDatasetUpdate*>(
               &_RegisterDatasetUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(RegisterDatasetUpdate& a, RegisterDatasetUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(RegisterDatasetUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RegisterDatasetUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RegisterDatasetUpdate* New() const final {
    return new RegisterDatasetUpdate();
  }

  RegisterDatasetUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RegisterDatasetUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RegisterDatasetUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RegisterDatasetUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RegisterDatasetUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.RegisterDatasetUpdate";
  }
  protected:
  explicit RegisterDatasetUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kDatasetIdFieldNumber = 1,
    kFingerprintFieldNumber = 2,
  };
  // int64 dataset_id = 1;
  void clear_dataset_id();
  ::PROTOBUF_NAMESPACE_ID::int64 dataset_id() const;
  void set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dataset_id() const;
  void _internal_set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // uint64 fingerprint = 2;
  void clear_fingerprint();
  ::PROTOBUF_NAMESPACE_ID::uint64 fingerprint() const;
  void set_fingerprint(::PROTOBUF_NAMESPACE_ID::uint64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_fingerprint() const;
  void _internal_set_fingerprint(::PROTOBUF_NAMESPACE_ID::uint64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.RegisterDatasetUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 dataset_id_;
  ::PROTOBUF_NAMESPACE_ID::uint64 fingerprint_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class RegisterWorkerUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.RegisterWorkerUpdate) */ {
 public:
  inline RegisterWorkerUpdate() : RegisterWorkerUpdate(nullptr) {}
  ~RegisterWorkerUpdate() override;
  explicit constexpr RegisterWorkerUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RegisterWorkerUpdate(const RegisterWorkerUpdate& from);
  RegisterWorkerUpdate(RegisterWorkerUpdate&& from) noexcept
    : RegisterWorkerUpdate() {
    *this = ::std::move(from);
  }

  inline RegisterWorkerUpdate& operator=(const RegisterWorkerUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline RegisterWorkerUpdate& operator=(RegisterWorkerUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RegisterWorkerUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const RegisterWorkerUpdate* internal_default_instance() {
    return reinterpret_cast<const RegisterWorkerUpdate*>(
               &_RegisterWorkerUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(RegisterWorkerUpdate& a, RegisterWorkerUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(RegisterWorkerUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RegisterWorkerUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RegisterWorkerUpdate* New() const final {
    return new RegisterWorkerUpdate();
  }

  RegisterWorkerUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RegisterWorkerUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RegisterWorkerUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RegisterWorkerUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RegisterWorkerUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.RegisterWorkerUpdate";
  }
  protected:
  explicit RegisterWorkerUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWorkerAddressFieldNumber = 1,
    kTransferAddressFieldNumber = 2,
  };
  // string worker_address = 1;
  void clear_worker_address();
  const std::string& worker_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_worker_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_worker_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_worker_address();
  void set_allocated_worker_address(std::string* worker_address);
  private:
  const std::string& _internal_worker_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_worker_address(const std::string& value);
  std::string* _internal_mutable_worker_address();
  public:

  // string transfer_address = 2;
  void clear_transfer_address();
  const std::string& transfer_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_transfer_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_transfer_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_transfer_address();
  void set_allocated_transfer_address(std::string* transfer_address);
  private:
  const std::string& _internal_transfer_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_transfer_address(const std::string& value);
  std::string* _internal_mutable_transfer_address();
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.RegisterWorkerUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr worker_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr transfer_address_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class NamedJobKeyDef final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.NamedJobKeyDef) */ {
 public:
  inline NamedJobKeyDef() : NamedJobKeyDef(nullptr) {}
  ~NamedJobKeyDef() override;
  explicit constexpr NamedJobKeyDef(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  NamedJobKeyDef(const NamedJobKeyDef& from);
  NamedJobKeyDef(NamedJobKeyDef&& from) noexcept
    : NamedJobKeyDef() {
    *this = ::std::move(from);
  }

  inline NamedJobKeyDef& operator=(const NamedJobKeyDef& from) {
    CopyFrom(from);
    return *this;
  }
  inline NamedJobKeyDef& operator=(NamedJobKeyDef&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const NamedJobKeyDef& default_instance() {
    return *internal_default_instance();
  }
  static inline const NamedJobKeyDef* internal_default_instance() {
    return reinterpret_cast<const NamedJobKeyDef*>(
               &_NamedJobKeyDef_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(NamedJobKeyDef& a, NamedJobKeyDef& b) {
    a.Swap(&b);
  }
  inline void Swap(NamedJobKeyDef* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NamedJobKeyDef* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline NamedJobKeyDef* New() const final {
    return new NamedJobKeyDef();
  }

  NamedJobKeyDef* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<NamedJobKeyDef>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const NamedJobKeyDef& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const NamedJobKeyDef& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(NamedJobKeyDef* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.NamedJobKeyDef";
  }
  protected:
  explicit NamedJobKeyDef(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNameFieldNumber = 1,
    kIndexFieldNumber = 2,
  };
  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_MUST_USE_RESULT std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // int64 index = 2;
  void clear_index();
  ::PROTOBUF_NAMESPACE_ID::int64 index() const;
  void set_index(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_index() const;
  void _internal_set_index(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.NamedJobKeyDef)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::int64 index_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class CreateJobUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CreateJobUpdate) */ {
 public:
  inline CreateJobUpdate() : CreateJobUpdate(nullptr) {}
  ~CreateJobUpdate() override;
  explicit constexpr CreateJobUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CreateJobUpdate(const CreateJobUpdate& from);
  CreateJobUpdate(CreateJobUpdate&& from) noexcept
    : CreateJobUpdate() {
    *this = ::std::move(from);
  }

  inline CreateJobUpdate& operator=(const CreateJobUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateJobUpdate& operator=(CreateJobUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateJobUpdate& default_instance() {
    return *internal_default_instance();
  }
  enum OptionalNumConsumersCase {
    kNumConsumers = 7,
    OPTIONAL_NUM_CONSUMERS_NOT_SET = 0,
  };

  static inline const CreateJobUpdate* internal_default_instance() {
    return reinterpret_cast<const CreateJobUpdate*>(
               &_CreateJobUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(CreateJobUpdate& a, CreateJobUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateJobUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateJobUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateJobUpdate* New() const final {
    return new CreateJobUpdate();
  }

  CreateJobUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateJobUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CreateJobUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CreateJobUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateJobUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.CreateJobUpdate";
  }
  protected:
  explicit CreateJobUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNamedJobKeyFieldNumber = 4,
    kJobIdFieldNumber = 1,
    kDatasetIdFieldNumber = 2,
    kProcessingModeFieldNumber = 3,
    kNumSplitProvidersFieldNumber = 8,
    kNumConsumersFieldNumber = 7,
  };
  // .tensorflow.data.NamedJobKeyDef named_job_key = 4;
  bool has_named_job_key() const;
  private:
  bool _internal_has_named_job_key() const;
  public:
  void clear_named_job_key();
  const ::tensorflow::data::NamedJobKeyDef& named_job_key() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::NamedJobKeyDef* release_named_job_key();
  ::tensorflow::data::NamedJobKeyDef* mutable_named_job_key();
  void set_allocated_named_job_key(::tensorflow::data::NamedJobKeyDef* named_job_key);
  private:
  const ::tensorflow::data::NamedJobKeyDef& _internal_named_job_key() const;
  ::tensorflow::data::NamedJobKeyDef* _internal_mutable_named_job_key();
  public:
  void unsafe_arena_set_allocated_named_job_key(
      ::tensorflow::data::NamedJobKeyDef* named_job_key);
  ::tensorflow::data::NamedJobKeyDef* unsafe_arena_release_named_job_key();

  // int64 job_id = 1;
  void clear_job_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_id() const;
  void set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_id() const;
  void _internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 dataset_id = 2;
  void clear_dataset_id();
  ::PROTOBUF_NAMESPACE_ID::int64 dataset_id() const;
  void set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_dataset_id() const;
  void _internal_set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // .tensorflow.data.ProcessingModeDef processing_mode = 3;
  void clear_processing_mode();
  ::tensorflow::data::ProcessingModeDef processing_mode() const;
  void set_processing_mode(::tensorflow::data::ProcessingModeDef value);
  private:
  ::tensorflow::data::ProcessingModeDef _internal_processing_mode() const;
  void _internal_set_processing_mode(::tensorflow::data::ProcessingModeDef value);
  public:

  // int64 num_split_providers = 8;
  void clear_num_split_providers();
  ::PROTOBUF_NAMESPACE_ID::int64 num_split_providers() const;
  void set_num_split_providers(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_split_providers() const;
  void _internal_set_num_split_providers(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 num_consumers = 7;
  bool has_num_consumers() const;
  private:
  bool _internal_has_num_consumers() const;
  public:
  void clear_num_consumers();
  ::PROTOBUF_NAMESPACE_ID::int64 num_consumers() const;
  void set_num_consumers(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_num_consumers() const;
  void _internal_set_num_consumers(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  void clear_optional_num_consumers();
  OptionalNumConsumersCase optional_num_consumers_case() const;
  // @@protoc_insertion_point(class_scope:tensorflow.data.CreateJobUpdate)
 private:
  class _Internal;
  void set_has_num_consumers();

  inline bool has_optional_num_consumers() const;
  inline void clear_has_optional_num_consumers();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::data::NamedJobKeyDef* named_job_key_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 dataset_id_;
  int processing_mode_;
  ::PROTOBUF_NAMESPACE_ID::int64 num_split_providers_;
  union OptionalNumConsumersUnion {
    constexpr OptionalNumConsumersUnion() : _constinit_{} {}
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
    ::PROTOBUF_NAMESPACE_ID::int64 num_consumers_;
  } optional_num_consumers_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class ProduceSplitUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.ProduceSplitUpdate) */ {
 public:
  inline ProduceSplitUpdate() : ProduceSplitUpdate(nullptr) {}
  ~ProduceSplitUpdate() override;
  explicit constexpr ProduceSplitUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ProduceSplitUpdate(const ProduceSplitUpdate& from);
  ProduceSplitUpdate(ProduceSplitUpdate&& from) noexcept
    : ProduceSplitUpdate() {
    *this = ::std::move(from);
  }

  inline ProduceSplitUpdate& operator=(const ProduceSplitUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline ProduceSplitUpdate& operator=(ProduceSplitUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ProduceSplitUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const ProduceSplitUpdate* internal_default_instance() {
    return reinterpret_cast<const ProduceSplitUpdate*>(
               &_ProduceSplitUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(ProduceSplitUpdate& a, ProduceSplitUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(ProduceSplitUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ProduceSplitUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ProduceSplitUpdate* New() const final {
    return new ProduceSplitUpdate();
  }

  ProduceSplitUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ProduceSplitUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ProduceSplitUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ProduceSplitUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ProduceSplitUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.ProduceSplitUpdate";
  }
  protected:
  explicit ProduceSplitUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kJobIdFieldNumber = 1,
    kRepetitionFieldNumber = 2,
    kSplitProviderIndexFieldNumber = 4,
    kFinishedFieldNumber = 3,
  };
  // int64 job_id = 1;
  void clear_job_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_id() const;
  void set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_id() const;
  void _internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 repetition = 2;
  void clear_repetition();
  ::PROTOBUF_NAMESPACE_ID::int64 repetition() const;
  void set_repetition(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_repetition() const;
  void _internal_set_repetition(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 split_provider_index = 4;
  void clear_split_provider_index();
  ::PROTOBUF_NAMESPACE_ID::int64 split_provider_index() const;
  void set_split_provider_index(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_split_provider_index() const;
  void _internal_set_split_provider_index(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // bool finished = 3;
  void clear_finished();
  bool finished() const;
  void set_finished(bool value);
  private:
  bool _internal_finished() const;
  void _internal_set_finished(bool value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.ProduceSplitUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 repetition_;
  ::PROTOBUF_NAMESPACE_ID::int64 split_provider_index_;
  bool finished_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class AcquireJobClientUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.AcquireJobClientUpdate) */ {
 public:
  inline AcquireJobClientUpdate() : AcquireJobClientUpdate(nullptr) {}
  ~AcquireJobClientUpdate() override;
  explicit constexpr AcquireJobClientUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AcquireJobClientUpdate(const AcquireJobClientUpdate& from);
  AcquireJobClientUpdate(AcquireJobClientUpdate&& from) noexcept
    : AcquireJobClientUpdate() {
    *this = ::std::move(from);
  }

  inline AcquireJobClientUpdate& operator=(const AcquireJobClientUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline AcquireJobClientUpdate& operator=(AcquireJobClientUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const AcquireJobClientUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const AcquireJobClientUpdate* internal_default_instance() {
    return reinterpret_cast<const AcquireJobClientUpdate*>(
               &_AcquireJobClientUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(AcquireJobClientUpdate& a, AcquireJobClientUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(AcquireJobClientUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(AcquireJobClientUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline AcquireJobClientUpdate* New() const final {
    return new AcquireJobClientUpdate();
  }

  AcquireJobClientUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<AcquireJobClientUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const AcquireJobClientUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const AcquireJobClientUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(AcquireJobClientUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.AcquireJobClientUpdate";
  }
  protected:
  explicit AcquireJobClientUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kJobIdFieldNumber = 1,
    kJobClientIdFieldNumber = 2,
  };
  // int64 job_id = 1;
  void clear_job_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_id() const;
  void set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_id() const;
  void _internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 job_client_id = 2;
  void clear_job_client_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_client_id() const;
  void set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_client_id() const;
  void _internal_set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.AcquireJobClientUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_client_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class ReleaseJobClientUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.ReleaseJobClientUpdate) */ {
 public:
  inline ReleaseJobClientUpdate() : ReleaseJobClientUpdate(nullptr) {}
  ~ReleaseJobClientUpdate() override;
  explicit constexpr ReleaseJobClientUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ReleaseJobClientUpdate(const ReleaseJobClientUpdate& from);
  ReleaseJobClientUpdate(ReleaseJobClientUpdate&& from) noexcept
    : ReleaseJobClientUpdate() {
    *this = ::std::move(from);
  }

  inline ReleaseJobClientUpdate& operator=(const ReleaseJobClientUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline ReleaseJobClientUpdate& operator=(ReleaseJobClientUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ReleaseJobClientUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const ReleaseJobClientUpdate* internal_default_instance() {
    return reinterpret_cast<const ReleaseJobClientUpdate*>(
               &_ReleaseJobClientUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

  friend void swap(ReleaseJobClientUpdate& a, ReleaseJobClientUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(ReleaseJobClientUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ReleaseJobClientUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ReleaseJobClientUpdate* New() const final {
    return new ReleaseJobClientUpdate();
  }

  ReleaseJobClientUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ReleaseJobClientUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ReleaseJobClientUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ReleaseJobClientUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ReleaseJobClientUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.ReleaseJobClientUpdate";
  }
  protected:
  explicit ReleaseJobClientUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kJobClientIdFieldNumber = 1,
    kTimeMicrosFieldNumber = 2,
  };
  // int64 job_client_id = 1;
  void clear_job_client_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_client_id() const;
  void set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_client_id() const;
  void _internal_set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 time_micros = 2;
  void clear_time_micros();
  ::PROTOBUF_NAMESPACE_ID::int64 time_micros() const;
  void set_time_micros(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_time_micros() const;
  void _internal_set_time_micros(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.ReleaseJobClientUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_client_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 time_micros_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class GarbageCollectJobUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.GarbageCollectJobUpdate) */ {
 public:
  inline GarbageCollectJobUpdate() : GarbageCollectJobUpdate(nullptr) {}
  ~GarbageCollectJobUpdate() override;
  explicit constexpr GarbageCollectJobUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  GarbageCollectJobUpdate(const GarbageCollectJobUpdate& from);
  GarbageCollectJobUpdate(GarbageCollectJobUpdate&& from) noexcept
    : GarbageCollectJobUpdate() {
    *this = ::std::move(from);
  }

  inline GarbageCollectJobUpdate& operator=(const GarbageCollectJobUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline GarbageCollectJobUpdate& operator=(GarbageCollectJobUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const GarbageCollectJobUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const GarbageCollectJobUpdate* internal_default_instance() {
    return reinterpret_cast<const GarbageCollectJobUpdate*>(
               &_GarbageCollectJobUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(GarbageCollectJobUpdate& a, GarbageCollectJobUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(GarbageCollectJobUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(GarbageCollectJobUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline GarbageCollectJobUpdate* New() const final {
    return new GarbageCollectJobUpdate();
  }

  GarbageCollectJobUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GarbageCollectJobUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const GarbageCollectJobUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const GarbageCollectJobUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(GarbageCollectJobUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.GarbageCollectJobUpdate";
  }
  protected:
  explicit GarbageCollectJobUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kJobIdFieldNumber = 1,
  };
  // int64 job_id = 1;
  void clear_job_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_id() const;
  void set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_id() const;
  void _internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.GarbageCollectJobUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class RemoveTaskUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.RemoveTaskUpdate) */ {
 public:
  inline RemoveTaskUpdate() : RemoveTaskUpdate(nullptr) {}
  ~RemoveTaskUpdate() override;
  explicit constexpr RemoveTaskUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  RemoveTaskUpdate(const RemoveTaskUpdate& from);
  RemoveTaskUpdate(RemoveTaskUpdate&& from) noexcept
    : RemoveTaskUpdate() {
    *this = ::std::move(from);
  }

  inline RemoveTaskUpdate& operator=(const RemoveTaskUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline RemoveTaskUpdate& operator=(RemoveTaskUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const RemoveTaskUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const RemoveTaskUpdate* internal_default_instance() {
    return reinterpret_cast<const RemoveTaskUpdate*>(
               &_RemoveTaskUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    9;

  friend void swap(RemoveTaskUpdate& a, RemoveTaskUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(RemoveTaskUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(RemoveTaskUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline RemoveTaskUpdate* New() const final {
    return new RemoveTaskUpdate();
  }

  RemoveTaskUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<RemoveTaskUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const RemoveTaskUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const RemoveTaskUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(RemoveTaskUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.RemoveTaskUpdate";
  }
  protected:
  explicit RemoveTaskUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTaskIdFieldNumber = 1,
  };
  // int64 task_id = 1;
  void clear_task_id();
  ::PROTOBUF_NAMESPACE_ID::int64 task_id() const;
  void set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_task_id() const;
  void _internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.RemoveTaskUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 task_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class TaskRejected final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.TaskRejected) */ {
 public:
  inline TaskRejected() : TaskRejected(nullptr) {}
  ~TaskRejected() override;
  explicit constexpr TaskRejected(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  TaskRejected(const TaskRejected& from);
  TaskRejected(TaskRejected&& from) noexcept
    : TaskRejected() {
    *this = ::std::move(from);
  }

  inline TaskRejected& operator=(const TaskRejected& from) {
    CopyFrom(from);
    return *this;
  }
  inline TaskRejected& operator=(TaskRejected&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const TaskRejected& default_instance() {
    return *internal_default_instance();
  }
  static inline const TaskRejected* internal_default_instance() {
    return reinterpret_cast<const TaskRejected*>(
               &_TaskRejected_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    10;

  friend void swap(TaskRejected& a, TaskRejected& b) {
    a.Swap(&b);
  }
  inline void Swap(TaskRejected* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TaskRejected* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline TaskRejected* New() const final {
    return new TaskRejected();
  }

  TaskRejected* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TaskRejected>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const TaskRejected& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const TaskRejected& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(TaskRejected* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.TaskRejected";
  }
  protected:
  explicit TaskRejected(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kNewTargetRoundFieldNumber = 1,
  };
  // int64 new_target_round = 1;
  void clear_new_target_round();
  ::PROTOBUF_NAMESPACE_ID::int64 new_target_round() const;
  void set_new_target_round(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_new_target_round() const;
  void _internal_set_new_target_round(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.TaskRejected)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 new_target_round_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class ClientHeartbeatUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.ClientHeartbeatUpdate) */ {
 public:
  inline ClientHeartbeatUpdate() : ClientHeartbeatUpdate(nullptr) {}
  ~ClientHeartbeatUpdate() override;
  explicit constexpr ClientHeartbeatUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ClientHeartbeatUpdate(const ClientHeartbeatUpdate& from);
  ClientHeartbeatUpdate(ClientHeartbeatUpdate&& from) noexcept
    : ClientHeartbeatUpdate() {
    *this = ::std::move(from);
  }

  inline ClientHeartbeatUpdate& operator=(const ClientHeartbeatUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline ClientHeartbeatUpdate& operator=(ClientHeartbeatUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const ClientHeartbeatUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const ClientHeartbeatUpdate* internal_default_instance() {
    return reinterpret_cast<const ClientHeartbeatUpdate*>(
               &_ClientHeartbeatUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    11;

  friend void swap(ClientHeartbeatUpdate& a, ClientHeartbeatUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(ClientHeartbeatUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ClientHeartbeatUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ClientHeartbeatUpdate* New() const final {
    return new ClientHeartbeatUpdate();
  }

  ClientHeartbeatUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ClientHeartbeatUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const ClientHeartbeatUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const ClientHeartbeatUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(ClientHeartbeatUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.ClientHeartbeatUpdate";
  }
  protected:
  explicit ClientHeartbeatUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTaskRejectedFieldNumber = 3,
    kJobClientIdFieldNumber = 1,
    kTaskAcceptedFieldNumber = 2,
  };
  // .tensorflow.data.TaskRejected task_rejected = 3;
  bool has_task_rejected() const;
  private:
  bool _internal_has_task_rejected() const;
  public:
  void clear_task_rejected();
  const ::tensorflow::data::TaskRejected& task_rejected() const;
  PROTOBUF_MUST_USE_RESULT ::tensorflow::data::TaskRejected* release_task_rejected();
  ::tensorflow::data::TaskRejected* mutable_task_rejected();
  void set_allocated_task_rejected(::tensorflow::data::TaskRejected* task_rejected);
  private:
  const ::tensorflow::data::TaskRejected& _internal_task_rejected() const;
  ::tensorflow::data::TaskRejected* _internal_mutable_task_rejected();
  public:
  void unsafe_arena_set_allocated_task_rejected(
      ::tensorflow::data::TaskRejected* task_rejected);
  ::tensorflow::data::TaskRejected* unsafe_arena_release_task_rejected();

  // int64 job_client_id = 1;
  void clear_job_client_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_client_id() const;
  void set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_client_id() const;
  void _internal_set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // bool task_accepted = 2;
  void clear_task_accepted();
  bool task_accepted() const;
  void set_task_accepted(bool value);
  private:
  bool _internal_task_accepted() const;
  void _internal_set_task_accepted(bool value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.ClientHeartbeatUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::tensorflow::data::TaskRejected* task_rejected_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_client_id_;
  bool task_accepted_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class CreatePendingTaskUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CreatePendingTaskUpdate) */ {
 public:
  inline CreatePendingTaskUpdate() : CreatePendingTaskUpdate(nullptr) {}
  ~CreatePendingTaskUpdate() override;
  explicit constexpr CreatePendingTaskUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CreatePendingTaskUpdate(const CreatePendingTaskUpdate& from);
  CreatePendingTaskUpdate(CreatePendingTaskUpdate&& from) noexcept
    : CreatePendingTaskUpdate() {
    *this = ::std::move(from);
  }

  inline CreatePendingTaskUpdate& operator=(const CreatePendingTaskUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreatePendingTaskUpdate& operator=(CreatePendingTaskUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreatePendingTaskUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreatePendingTaskUpdate* internal_default_instance() {
    return reinterpret_cast<const CreatePendingTaskUpdate*>(
               &_CreatePendingTaskUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    12;

  friend void swap(CreatePendingTaskUpdate& a, CreatePendingTaskUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(CreatePendingTaskUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreatePendingTaskUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreatePendingTaskUpdate* New() const final {
    return new CreatePendingTaskUpdate();
  }

  CreatePendingTaskUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreatePendingTaskUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CreatePendingTaskUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CreatePendingTaskUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreatePendingTaskUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.CreatePendingTaskUpdate";
  }
  protected:
  explicit CreatePendingTaskUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWorkerAddressFieldNumber = 3,
    kTransferAddressFieldNumber = 4,
    kTaskIdFieldNumber = 1,
    kJobIdFieldNumber = 2,
    kStartingRoundFieldNumber = 5,
  };
  // string worker_address = 3;
  void clear_worker_address();
  const std::string& worker_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_worker_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_worker_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_worker_address();
  void set_allocated_worker_address(std::string* worker_address);
  private:
  const std::string& _internal_worker_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_worker_address(const std::string& value);
  std::string* _internal_mutable_worker_address();
  public:

  // string transfer_address = 4;
  void clear_transfer_address();
  const std::string& transfer_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_transfer_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_transfer_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_transfer_address();
  void set_allocated_transfer_address(std::string* transfer_address);
  private:
  const std::string& _internal_transfer_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_transfer_address(const std::string& value);
  std::string* _internal_mutable_transfer_address();
  public:

  // int64 task_id = 1;
  void clear_task_id();
  ::PROTOBUF_NAMESPACE_ID::int64 task_id() const;
  void set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_task_id() const;
  void _internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 job_id = 2;
  void clear_job_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_id() const;
  void set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_id() const;
  void _internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 starting_round = 5;
  void clear_starting_round();
  ::PROTOBUF_NAMESPACE_ID::int64 starting_round() const;
  void set_starting_round(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_starting_round() const;
  void _internal_set_starting_round(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.CreatePendingTaskUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr worker_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr transfer_address_;
  ::PROTOBUF_NAMESPACE_ID::int64 task_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 starting_round_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class CreateTaskUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.CreateTaskUpdate) */ {
 public:
  inline CreateTaskUpdate() : CreateTaskUpdate(nullptr) {}
  ~CreateTaskUpdate() override;
  explicit constexpr CreateTaskUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  CreateTaskUpdate(const CreateTaskUpdate& from);
  CreateTaskUpdate(CreateTaskUpdate&& from) noexcept
    : CreateTaskUpdate() {
    *this = ::std::move(from);
  }

  inline CreateTaskUpdate& operator=(const CreateTaskUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateTaskUpdate& operator=(CreateTaskUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const CreateTaskUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const CreateTaskUpdate* internal_default_instance() {
    return reinterpret_cast<const CreateTaskUpdate*>(
               &_CreateTaskUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    13;

  friend void swap(CreateTaskUpdate& a, CreateTaskUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateTaskUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(CreateTaskUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline CreateTaskUpdate* New() const final {
    return new CreateTaskUpdate();
  }

  CreateTaskUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateTaskUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const CreateTaskUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const CreateTaskUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(CreateTaskUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.CreateTaskUpdate";
  }
  protected:
  explicit CreateTaskUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kWorkerAddressFieldNumber = 4,
    kTransferAddressFieldNumber = 6,
    kTaskIdFieldNumber = 1,
    kJobIdFieldNumber = 2,
  };
  // string worker_address = 4;
  void clear_worker_address();
  const std::string& worker_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_worker_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_worker_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_worker_address();
  void set_allocated_worker_address(std::string* worker_address);
  private:
  const std::string& _internal_worker_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_worker_address(const std::string& value);
  std::string* _internal_mutable_worker_address();
  public:

  // string transfer_address = 6;
  void clear_transfer_address();
  const std::string& transfer_address() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_transfer_address(ArgT0&& arg0, ArgT... args);
  std::string* mutable_transfer_address();
  PROTOBUF_MUST_USE_RESULT std::string* release_transfer_address();
  void set_allocated_transfer_address(std::string* transfer_address);
  private:
  const std::string& _internal_transfer_address() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_transfer_address(const std::string& value);
  std::string* _internal_mutable_transfer_address();
  public:

  // int64 task_id = 1;
  void clear_task_id();
  ::PROTOBUF_NAMESPACE_ID::int64 task_id() const;
  void set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_task_id() const;
  void _internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 job_id = 2;
  void clear_job_id();
  ::PROTOBUF_NAMESPACE_ID::int64 job_id() const;
  void set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_job_id() const;
  void _internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.CreateTaskUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr worker_address_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr transfer_address_;
  ::PROTOBUF_NAMESPACE_ID::int64 task_id_;
  ::PROTOBUF_NAMESPACE_ID::int64 job_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// -------------------------------------------------------------------

class FinishTaskUpdate final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.data.FinishTaskUpdate) */ {
 public:
  inline FinishTaskUpdate() : FinishTaskUpdate(nullptr) {}
  ~FinishTaskUpdate() override;
  explicit constexpr FinishTaskUpdate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  FinishTaskUpdate(const FinishTaskUpdate& from);
  FinishTaskUpdate(FinishTaskUpdate&& from) noexcept
    : FinishTaskUpdate() {
    *this = ::std::move(from);
  }

  inline FinishTaskUpdate& operator=(const FinishTaskUpdate& from) {
    CopyFrom(from);
    return *this;
  }
  inline FinishTaskUpdate& operator=(FinishTaskUpdate&& from) noexcept {
    if (this == &from) return *this;
    if (GetOwningArena() == from.GetOwningArena()
  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
        && GetOwningArena() != nullptr
  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
    ) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return default_instance().GetMetadata().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return default_instance().GetMetadata().reflection;
  }
  static const FinishTaskUpdate& default_instance() {
    return *internal_default_instance();
  }
  static inline const FinishTaskUpdate* internal_default_instance() {
    return reinterpret_cast<const FinishTaskUpdate*>(
               &_FinishTaskUpdate_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    14;

  friend void swap(FinishTaskUpdate& a, FinishTaskUpdate& b) {
    a.Swap(&b);
  }
  inline void Swap(FinishTaskUpdate* other) {
    if (other == this) return;
    if (GetOwningArena() == other->GetOwningArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(FinishTaskUpdate* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline FinishTaskUpdate* New() const final {
    return new FinishTaskUpdate();
  }

  FinishTaskUpdate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<FinishTaskUpdate>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const FinishTaskUpdate& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const FinishTaskUpdate& from);
  private:
  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
  public:
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const final;
  void InternalSwap(FinishTaskUpdate* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "tensorflow.data.FinishTaskUpdate";
  }
  protected:
  explicit FinishTaskUpdate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                       bool is_message_owned = false);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  static const ClassData _class_data_;
  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTaskIdFieldNumber = 1,
  };
  // int64 task_id = 1;
  void clear_task_id();
  ::PROTOBUF_NAMESPACE_ID::int64 task_id() const;
  void set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_task_id() const;
  void _internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:tensorflow.data.FinishTaskUpdate)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 task_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Update

// .tensorflow.data.RegisterDatasetUpdate register_dataset = 1;
inline bool Update::_internal_has_register_dataset() const {
  return update_type_case() == kRegisterDataset;
}
inline bool Update::has_register_dataset() const {
  return _internal_has_register_dataset();
}
inline void Update::set_has_register_dataset() {
  _oneof_case_[0] = kRegisterDataset;
}
inline void Update::clear_register_dataset() {
  if (_internal_has_register_dataset()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.register_dataset_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::RegisterDatasetUpdate* Update::release_register_dataset() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.register_dataset)
  if (_internal_has_register_dataset()) {
    clear_has_update_type();
      ::tensorflow::data::RegisterDatasetUpdate* temp = update_type_.register_dataset_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.register_dataset_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::RegisterDatasetUpdate& Update::_internal_register_dataset() const {
  return _internal_has_register_dataset()
      ? *update_type_.register_dataset_
      : reinterpret_cast< ::tensorflow::data::RegisterDatasetUpdate&>(::tensorflow::data::_RegisterDatasetUpdate_default_instance_);
}
inline const ::tensorflow::data::RegisterDatasetUpdate& Update::register_dataset() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.register_dataset)
  return _internal_register_dataset();
}
inline ::tensorflow::data::RegisterDatasetUpdate* Update::unsafe_arena_release_register_dataset() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.register_dataset)
  if (_internal_has_register_dataset()) {
    clear_has_update_type();
    ::tensorflow::data::RegisterDatasetUpdate* temp = update_type_.register_dataset_;
    update_type_.register_dataset_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_register_dataset(::tensorflow::data::RegisterDatasetUpdate* register_dataset) {
  clear_update_type();
  if (register_dataset) {
    set_has_register_dataset();
    update_type_.register_dataset_ = register_dataset;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.register_dataset)
}
inline ::tensorflow::data::RegisterDatasetUpdate* Update::_internal_mutable_register_dataset() {
  if (!_internal_has_register_dataset()) {
    clear_update_type();
    set_has_register_dataset();
    update_type_.register_dataset_ = CreateMaybeMessage< ::tensorflow::data::RegisterDatasetUpdate >(GetArenaForAllocation());
  }
  return update_type_.register_dataset_;
}
inline ::tensorflow::data::RegisterDatasetUpdate* Update::mutable_register_dataset() {
  ::tensorflow::data::RegisterDatasetUpdate* _msg = _internal_mutable_register_dataset();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.register_dataset)
  return _msg;
}

// .tensorflow.data.RegisterWorkerUpdate register_worker = 5;
inline bool Update::_internal_has_register_worker() const {
  return update_type_case() == kRegisterWorker;
}
inline bool Update::has_register_worker() const {
  return _internal_has_register_worker();
}
inline void Update::set_has_register_worker() {
  _oneof_case_[0] = kRegisterWorker;
}
inline void Update::clear_register_worker() {
  if (_internal_has_register_worker()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.register_worker_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::RegisterWorkerUpdate* Update::release_register_worker() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.register_worker)
  if (_internal_has_register_worker()) {
    clear_has_update_type();
      ::tensorflow::data::RegisterWorkerUpdate* temp = update_type_.register_worker_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.register_worker_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::RegisterWorkerUpdate& Update::_internal_register_worker() const {
  return _internal_has_register_worker()
      ? *update_type_.register_worker_
      : reinterpret_cast< ::tensorflow::data::RegisterWorkerUpdate&>(::tensorflow::data::_RegisterWorkerUpdate_default_instance_);
}
inline const ::tensorflow::data::RegisterWorkerUpdate& Update::register_worker() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.register_worker)
  return _internal_register_worker();
}
inline ::tensorflow::data::RegisterWorkerUpdate* Update::unsafe_arena_release_register_worker() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.register_worker)
  if (_internal_has_register_worker()) {
    clear_has_update_type();
    ::tensorflow::data::RegisterWorkerUpdate* temp = update_type_.register_worker_;
    update_type_.register_worker_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_register_worker(::tensorflow::data::RegisterWorkerUpdate* register_worker) {
  clear_update_type();
  if (register_worker) {
    set_has_register_worker();
    update_type_.register_worker_ = register_worker;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.register_worker)
}
inline ::tensorflow::data::RegisterWorkerUpdate* Update::_internal_mutable_register_worker() {
  if (!_internal_has_register_worker()) {
    clear_update_type();
    set_has_register_worker();
    update_type_.register_worker_ = CreateMaybeMessage< ::tensorflow::data::RegisterWorkerUpdate >(GetArenaForAllocation());
  }
  return update_type_.register_worker_;
}
inline ::tensorflow::data::RegisterWorkerUpdate* Update::mutable_register_worker() {
  ::tensorflow::data::RegisterWorkerUpdate* _msg = _internal_mutable_register_worker();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.register_worker)
  return _msg;
}

// .tensorflow.data.CreateJobUpdate create_job = 2;
inline bool Update::_internal_has_create_job() const {
  return update_type_case() == kCreateJob;
}
inline bool Update::has_create_job() const {
  return _internal_has_create_job();
}
inline void Update::set_has_create_job() {
  _oneof_case_[0] = kCreateJob;
}
inline void Update::clear_create_job() {
  if (_internal_has_create_job()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.create_job_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::CreateJobUpdate* Update::release_create_job() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.create_job)
  if (_internal_has_create_job()) {
    clear_has_update_type();
      ::tensorflow::data::CreateJobUpdate* temp = update_type_.create_job_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.create_job_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::CreateJobUpdate& Update::_internal_create_job() const {
  return _internal_has_create_job()
      ? *update_type_.create_job_
      : reinterpret_cast< ::tensorflow::data::CreateJobUpdate&>(::tensorflow::data::_CreateJobUpdate_default_instance_);
}
inline const ::tensorflow::data::CreateJobUpdate& Update::create_job() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.create_job)
  return _internal_create_job();
}
inline ::tensorflow::data::CreateJobUpdate* Update::unsafe_arena_release_create_job() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.create_job)
  if (_internal_has_create_job()) {
    clear_has_update_type();
    ::tensorflow::data::CreateJobUpdate* temp = update_type_.create_job_;
    update_type_.create_job_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_create_job(::tensorflow::data::CreateJobUpdate* create_job) {
  clear_update_type();
  if (create_job) {
    set_has_create_job();
    update_type_.create_job_ = create_job;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.create_job)
}
inline ::tensorflow::data::CreateJobUpdate* Update::_internal_mutable_create_job() {
  if (!_internal_has_create_job()) {
    clear_update_type();
    set_has_create_job();
    update_type_.create_job_ = CreateMaybeMessage< ::tensorflow::data::CreateJobUpdate >(GetArenaForAllocation());
  }
  return update_type_.create_job_;
}
inline ::tensorflow::data::CreateJobUpdate* Update::mutable_create_job() {
  ::tensorflow::data::CreateJobUpdate* _msg = _internal_mutable_create_job();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.create_job)
  return _msg;
}

// .tensorflow.data.ProduceSplitUpdate produce_split = 8;
inline bool Update::_internal_has_produce_split() const {
  return update_type_case() == kProduceSplit;
}
inline bool Update::has_produce_split() const {
  return _internal_has_produce_split();
}
inline void Update::set_has_produce_split() {
  _oneof_case_[0] = kProduceSplit;
}
inline void Update::clear_produce_split() {
  if (_internal_has_produce_split()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.produce_split_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::ProduceSplitUpdate* Update::release_produce_split() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.produce_split)
  if (_internal_has_produce_split()) {
    clear_has_update_type();
      ::tensorflow::data::ProduceSplitUpdate* temp = update_type_.produce_split_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.produce_split_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::ProduceSplitUpdate& Update::_internal_produce_split() const {
  return _internal_has_produce_split()
      ? *update_type_.produce_split_
      : reinterpret_cast< ::tensorflow::data::ProduceSplitUpdate&>(::tensorflow::data::_ProduceSplitUpdate_default_instance_);
}
inline const ::tensorflow::data::ProduceSplitUpdate& Update::produce_split() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.produce_split)
  return _internal_produce_split();
}
inline ::tensorflow::data::ProduceSplitUpdate* Update::unsafe_arena_release_produce_split() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.produce_split)
  if (_internal_has_produce_split()) {
    clear_has_update_type();
    ::tensorflow::data::ProduceSplitUpdate* temp = update_type_.produce_split_;
    update_type_.produce_split_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_produce_split(::tensorflow::data::ProduceSplitUpdate* produce_split) {
  clear_update_type();
  if (produce_split) {
    set_has_produce_split();
    update_type_.produce_split_ = produce_split;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.produce_split)
}
inline ::tensorflow::data::ProduceSplitUpdate* Update::_internal_mutable_produce_split() {
  if (!_internal_has_produce_split()) {
    clear_update_type();
    set_has_produce_split();
    update_type_.produce_split_ = CreateMaybeMessage< ::tensorflow::data::ProduceSplitUpdate >(GetArenaForAllocation());
  }
  return update_type_.produce_split_;
}
inline ::tensorflow::data::ProduceSplitUpdate* Update::mutable_produce_split() {
  ::tensorflow::data::ProduceSplitUpdate* _msg = _internal_mutable_produce_split();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.produce_split)
  return _msg;
}

// .tensorflow.data.AcquireJobClientUpdate acquire_job_client = 6;
inline bool Update::_internal_has_acquire_job_client() const {
  return update_type_case() == kAcquireJobClient;
}
inline bool Update::has_acquire_job_client() const {
  return _internal_has_acquire_job_client();
}
inline void Update::set_has_acquire_job_client() {
  _oneof_case_[0] = kAcquireJobClient;
}
inline void Update::clear_acquire_job_client() {
  if (_internal_has_acquire_job_client()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.acquire_job_client_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::AcquireJobClientUpdate* Update::release_acquire_job_client() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.acquire_job_client)
  if (_internal_has_acquire_job_client()) {
    clear_has_update_type();
      ::tensorflow::data::AcquireJobClientUpdate* temp = update_type_.acquire_job_client_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.acquire_job_client_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::AcquireJobClientUpdate& Update::_internal_acquire_job_client() const {
  return _internal_has_acquire_job_client()
      ? *update_type_.acquire_job_client_
      : reinterpret_cast< ::tensorflow::data::AcquireJobClientUpdate&>(::tensorflow::data::_AcquireJobClientUpdate_default_instance_);
}
inline const ::tensorflow::data::AcquireJobClientUpdate& Update::acquire_job_client() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.acquire_job_client)
  return _internal_acquire_job_client();
}
inline ::tensorflow::data::AcquireJobClientUpdate* Update::unsafe_arena_release_acquire_job_client() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.acquire_job_client)
  if (_internal_has_acquire_job_client()) {
    clear_has_update_type();
    ::tensorflow::data::AcquireJobClientUpdate* temp = update_type_.acquire_job_client_;
    update_type_.acquire_job_client_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_acquire_job_client(::tensorflow::data::AcquireJobClientUpdate* acquire_job_client) {
  clear_update_type();
  if (acquire_job_client) {
    set_has_acquire_job_client();
    update_type_.acquire_job_client_ = acquire_job_client;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.acquire_job_client)
}
inline ::tensorflow::data::AcquireJobClientUpdate* Update::_internal_mutable_acquire_job_client() {
  if (!_internal_has_acquire_job_client()) {
    clear_update_type();
    set_has_acquire_job_client();
    update_type_.acquire_job_client_ = CreateMaybeMessage< ::tensorflow::data::AcquireJobClientUpdate >(GetArenaForAllocation());
  }
  return update_type_.acquire_job_client_;
}
inline ::tensorflow::data::AcquireJobClientUpdate* Update::mutable_acquire_job_client() {
  ::tensorflow::data::AcquireJobClientUpdate* _msg = _internal_mutable_acquire_job_client();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.acquire_job_client)
  return _msg;
}

// .tensorflow.data.ReleaseJobClientUpdate release_job_client = 7;
inline bool Update::_internal_has_release_job_client() const {
  return update_type_case() == kReleaseJobClient;
}
inline bool Update::has_release_job_client() const {
  return _internal_has_release_job_client();
}
inline void Update::set_has_release_job_client() {
  _oneof_case_[0] = kReleaseJobClient;
}
inline void Update::clear_release_job_client() {
  if (_internal_has_release_job_client()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.release_job_client_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::ReleaseJobClientUpdate* Update::release_release_job_client() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.release_job_client)
  if (_internal_has_release_job_client()) {
    clear_has_update_type();
      ::tensorflow::data::ReleaseJobClientUpdate* temp = update_type_.release_job_client_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.release_job_client_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::ReleaseJobClientUpdate& Update::_internal_release_job_client() const {
  return _internal_has_release_job_client()
      ? *update_type_.release_job_client_
      : reinterpret_cast< ::tensorflow::data::ReleaseJobClientUpdate&>(::tensorflow::data::_ReleaseJobClientUpdate_default_instance_);
}
inline const ::tensorflow::data::ReleaseJobClientUpdate& Update::release_job_client() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.release_job_client)
  return _internal_release_job_client();
}
inline ::tensorflow::data::ReleaseJobClientUpdate* Update::unsafe_arena_release_release_job_client() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.release_job_client)
  if (_internal_has_release_job_client()) {
    clear_has_update_type();
    ::tensorflow::data::ReleaseJobClientUpdate* temp = update_type_.release_job_client_;
    update_type_.release_job_client_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_release_job_client(::tensorflow::data::ReleaseJobClientUpdate* release_job_client) {
  clear_update_type();
  if (release_job_client) {
    set_has_release_job_client();
    update_type_.release_job_client_ = release_job_client;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.release_job_client)
}
inline ::tensorflow::data::ReleaseJobClientUpdate* Update::_internal_mutable_release_job_client() {
  if (!_internal_has_release_job_client()) {
    clear_update_type();
    set_has_release_job_client();
    update_type_.release_job_client_ = CreateMaybeMessage< ::tensorflow::data::ReleaseJobClientUpdate >(GetArenaForAllocation());
  }
  return update_type_.release_job_client_;
}
inline ::tensorflow::data::ReleaseJobClientUpdate* Update::mutable_release_job_client() {
  ::tensorflow::data::ReleaseJobClientUpdate* _msg = _internal_mutable_release_job_client();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.release_job_client)
  return _msg;
}

// .tensorflow.data.GarbageCollectJobUpdate garbage_collect_job = 12;
inline bool Update::_internal_has_garbage_collect_job() const {
  return update_type_case() == kGarbageCollectJob;
}
inline bool Update::has_garbage_collect_job() const {
  return _internal_has_garbage_collect_job();
}
inline void Update::set_has_garbage_collect_job() {
  _oneof_case_[0] = kGarbageCollectJob;
}
inline void Update::clear_garbage_collect_job() {
  if (_internal_has_garbage_collect_job()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.garbage_collect_job_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::GarbageCollectJobUpdate* Update::release_garbage_collect_job() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.garbage_collect_job)
  if (_internal_has_garbage_collect_job()) {
    clear_has_update_type();
      ::tensorflow::data::GarbageCollectJobUpdate* temp = update_type_.garbage_collect_job_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.garbage_collect_job_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::GarbageCollectJobUpdate& Update::_internal_garbage_collect_job() const {
  return _internal_has_garbage_collect_job()
      ? *update_type_.garbage_collect_job_
      : reinterpret_cast< ::tensorflow::data::GarbageCollectJobUpdate&>(::tensorflow::data::_GarbageCollectJobUpdate_default_instance_);
}
inline const ::tensorflow::data::GarbageCollectJobUpdate& Update::garbage_collect_job() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.garbage_collect_job)
  return _internal_garbage_collect_job();
}
inline ::tensorflow::data::GarbageCollectJobUpdate* Update::unsafe_arena_release_garbage_collect_job() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.garbage_collect_job)
  if (_internal_has_garbage_collect_job()) {
    clear_has_update_type();
    ::tensorflow::data::GarbageCollectJobUpdate* temp = update_type_.garbage_collect_job_;
    update_type_.garbage_collect_job_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_garbage_collect_job(::tensorflow::data::GarbageCollectJobUpdate* garbage_collect_job) {
  clear_update_type();
  if (garbage_collect_job) {
    set_has_garbage_collect_job();
    update_type_.garbage_collect_job_ = garbage_collect_job;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.garbage_collect_job)
}
inline ::tensorflow::data::GarbageCollectJobUpdate* Update::_internal_mutable_garbage_collect_job() {
  if (!_internal_has_garbage_collect_job()) {
    clear_update_type();
    set_has_garbage_collect_job();
    update_type_.garbage_collect_job_ = CreateMaybeMessage< ::tensorflow::data::GarbageCollectJobUpdate >(GetArenaForAllocation());
  }
  return update_type_.garbage_collect_job_;
}
inline ::tensorflow::data::GarbageCollectJobUpdate* Update::mutable_garbage_collect_job() {
  ::tensorflow::data::GarbageCollectJobUpdate* _msg = _internal_mutable_garbage_collect_job();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.garbage_collect_job)
  return _msg;
}

// .tensorflow.data.RemoveTaskUpdate remove_task = 11;
inline bool Update::_internal_has_remove_task() const {
  return update_type_case() == kRemoveTask;
}
inline bool Update::has_remove_task() const {
  return _internal_has_remove_task();
}
inline void Update::set_has_remove_task() {
  _oneof_case_[0] = kRemoveTask;
}
inline void Update::clear_remove_task() {
  if (_internal_has_remove_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.remove_task_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::RemoveTaskUpdate* Update::release_remove_task() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.remove_task)
  if (_internal_has_remove_task()) {
    clear_has_update_type();
      ::tensorflow::data::RemoveTaskUpdate* temp = update_type_.remove_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.remove_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::RemoveTaskUpdate& Update::_internal_remove_task() const {
  return _internal_has_remove_task()
      ? *update_type_.remove_task_
      : reinterpret_cast< ::tensorflow::data::RemoveTaskUpdate&>(::tensorflow::data::_RemoveTaskUpdate_default_instance_);
}
inline const ::tensorflow::data::RemoveTaskUpdate& Update::remove_task() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.remove_task)
  return _internal_remove_task();
}
inline ::tensorflow::data::RemoveTaskUpdate* Update::unsafe_arena_release_remove_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.remove_task)
  if (_internal_has_remove_task()) {
    clear_has_update_type();
    ::tensorflow::data::RemoveTaskUpdate* temp = update_type_.remove_task_;
    update_type_.remove_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_remove_task(::tensorflow::data::RemoveTaskUpdate* remove_task) {
  clear_update_type();
  if (remove_task) {
    set_has_remove_task();
    update_type_.remove_task_ = remove_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.remove_task)
}
inline ::tensorflow::data::RemoveTaskUpdate* Update::_internal_mutable_remove_task() {
  if (!_internal_has_remove_task()) {
    clear_update_type();
    set_has_remove_task();
    update_type_.remove_task_ = CreateMaybeMessage< ::tensorflow::data::RemoveTaskUpdate >(GetArenaForAllocation());
  }
  return update_type_.remove_task_;
}
inline ::tensorflow::data::RemoveTaskUpdate* Update::mutable_remove_task() {
  ::tensorflow::data::RemoveTaskUpdate* _msg = _internal_mutable_remove_task();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.remove_task)
  return _msg;
}

// .tensorflow.data.CreatePendingTaskUpdate create_pending_task = 9;
inline bool Update::_internal_has_create_pending_task() const {
  return update_type_case() == kCreatePendingTask;
}
inline bool Update::has_create_pending_task() const {
  return _internal_has_create_pending_task();
}
inline void Update::set_has_create_pending_task() {
  _oneof_case_[0] = kCreatePendingTask;
}
inline void Update::clear_create_pending_task() {
  if (_internal_has_create_pending_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.create_pending_task_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::CreatePendingTaskUpdate* Update::release_create_pending_task() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.create_pending_task)
  if (_internal_has_create_pending_task()) {
    clear_has_update_type();
      ::tensorflow::data::CreatePendingTaskUpdate* temp = update_type_.create_pending_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.create_pending_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::CreatePendingTaskUpdate& Update::_internal_create_pending_task() const {
  return _internal_has_create_pending_task()
      ? *update_type_.create_pending_task_
      : reinterpret_cast< ::tensorflow::data::CreatePendingTaskUpdate&>(::tensorflow::data::_CreatePendingTaskUpdate_default_instance_);
}
inline const ::tensorflow::data::CreatePendingTaskUpdate& Update::create_pending_task() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.create_pending_task)
  return _internal_create_pending_task();
}
inline ::tensorflow::data::CreatePendingTaskUpdate* Update::unsafe_arena_release_create_pending_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.create_pending_task)
  if (_internal_has_create_pending_task()) {
    clear_has_update_type();
    ::tensorflow::data::CreatePendingTaskUpdate* temp = update_type_.create_pending_task_;
    update_type_.create_pending_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_create_pending_task(::tensorflow::data::CreatePendingTaskUpdate* create_pending_task) {
  clear_update_type();
  if (create_pending_task) {
    set_has_create_pending_task();
    update_type_.create_pending_task_ = create_pending_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.create_pending_task)
}
inline ::tensorflow::data::CreatePendingTaskUpdate* Update::_internal_mutable_create_pending_task() {
  if (!_internal_has_create_pending_task()) {
    clear_update_type();
    set_has_create_pending_task();
    update_type_.create_pending_task_ = CreateMaybeMessage< ::tensorflow::data::CreatePendingTaskUpdate >(GetArenaForAllocation());
  }
  return update_type_.create_pending_task_;
}
inline ::tensorflow::data::CreatePendingTaskUpdate* Update::mutable_create_pending_task() {
  ::tensorflow::data::CreatePendingTaskUpdate* _msg = _internal_mutable_create_pending_task();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.create_pending_task)
  return _msg;
}

// .tensorflow.data.ClientHeartbeatUpdate client_heartbeat = 10;
inline bool Update::_internal_has_client_heartbeat() const {
  return update_type_case() == kClientHeartbeat;
}
inline bool Update::has_client_heartbeat() const {
  return _internal_has_client_heartbeat();
}
inline void Update::set_has_client_heartbeat() {
  _oneof_case_[0] = kClientHeartbeat;
}
inline void Update::clear_client_heartbeat() {
  if (_internal_has_client_heartbeat()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.client_heartbeat_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::ClientHeartbeatUpdate* Update::release_client_heartbeat() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.client_heartbeat)
  if (_internal_has_client_heartbeat()) {
    clear_has_update_type();
      ::tensorflow::data::ClientHeartbeatUpdate* temp = update_type_.client_heartbeat_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.client_heartbeat_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::ClientHeartbeatUpdate& Update::_internal_client_heartbeat() const {
  return _internal_has_client_heartbeat()
      ? *update_type_.client_heartbeat_
      : reinterpret_cast< ::tensorflow::data::ClientHeartbeatUpdate&>(::tensorflow::data::_ClientHeartbeatUpdate_default_instance_);
}
inline const ::tensorflow::data::ClientHeartbeatUpdate& Update::client_heartbeat() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.client_heartbeat)
  return _internal_client_heartbeat();
}
inline ::tensorflow::data::ClientHeartbeatUpdate* Update::unsafe_arena_release_client_heartbeat() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.client_heartbeat)
  if (_internal_has_client_heartbeat()) {
    clear_has_update_type();
    ::tensorflow::data::ClientHeartbeatUpdate* temp = update_type_.client_heartbeat_;
    update_type_.client_heartbeat_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_client_heartbeat(::tensorflow::data::ClientHeartbeatUpdate* client_heartbeat) {
  clear_update_type();
  if (client_heartbeat) {
    set_has_client_heartbeat();
    update_type_.client_heartbeat_ = client_heartbeat;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.client_heartbeat)
}
inline ::tensorflow::data::ClientHeartbeatUpdate* Update::_internal_mutable_client_heartbeat() {
  if (!_internal_has_client_heartbeat()) {
    clear_update_type();
    set_has_client_heartbeat();
    update_type_.client_heartbeat_ = CreateMaybeMessage< ::tensorflow::data::ClientHeartbeatUpdate >(GetArenaForAllocation());
  }
  return update_type_.client_heartbeat_;
}
inline ::tensorflow::data::ClientHeartbeatUpdate* Update::mutable_client_heartbeat() {
  ::tensorflow::data::ClientHeartbeatUpdate* _msg = _internal_mutable_client_heartbeat();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.client_heartbeat)
  return _msg;
}

// .tensorflow.data.CreateTaskUpdate create_task = 3;
inline bool Update::_internal_has_create_task() const {
  return update_type_case() == kCreateTask;
}
inline bool Update::has_create_task() const {
  return _internal_has_create_task();
}
inline void Update::set_has_create_task() {
  _oneof_case_[0] = kCreateTask;
}
inline void Update::clear_create_task() {
  if (_internal_has_create_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.create_task_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::CreateTaskUpdate* Update::release_create_task() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.create_task)
  if (_internal_has_create_task()) {
    clear_has_update_type();
      ::tensorflow::data::CreateTaskUpdate* temp = update_type_.create_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.create_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::CreateTaskUpdate& Update::_internal_create_task() const {
  return _internal_has_create_task()
      ? *update_type_.create_task_
      : reinterpret_cast< ::tensorflow::data::CreateTaskUpdate&>(::tensorflow::data::_CreateTaskUpdate_default_instance_);
}
inline const ::tensorflow::data::CreateTaskUpdate& Update::create_task() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.create_task)
  return _internal_create_task();
}
inline ::tensorflow::data::CreateTaskUpdate* Update::unsafe_arena_release_create_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.create_task)
  if (_internal_has_create_task()) {
    clear_has_update_type();
    ::tensorflow::data::CreateTaskUpdate* temp = update_type_.create_task_;
    update_type_.create_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_create_task(::tensorflow::data::CreateTaskUpdate* create_task) {
  clear_update_type();
  if (create_task) {
    set_has_create_task();
    update_type_.create_task_ = create_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.create_task)
}
inline ::tensorflow::data::CreateTaskUpdate* Update::_internal_mutable_create_task() {
  if (!_internal_has_create_task()) {
    clear_update_type();
    set_has_create_task();
    update_type_.create_task_ = CreateMaybeMessage< ::tensorflow::data::CreateTaskUpdate >(GetArenaForAllocation());
  }
  return update_type_.create_task_;
}
inline ::tensorflow::data::CreateTaskUpdate* Update::mutable_create_task() {
  ::tensorflow::data::CreateTaskUpdate* _msg = _internal_mutable_create_task();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.create_task)
  return _msg;
}

// .tensorflow.data.FinishTaskUpdate finish_task = 4;
inline bool Update::_internal_has_finish_task() const {
  return update_type_case() == kFinishTask;
}
inline bool Update::has_finish_task() const {
  return _internal_has_finish_task();
}
inline void Update::set_has_finish_task() {
  _oneof_case_[0] = kFinishTask;
}
inline void Update::clear_finish_task() {
  if (_internal_has_finish_task()) {
    if (GetArenaForAllocation() == nullptr) {
      delete update_type_.finish_task_;
    }
    clear_has_update_type();
  }
}
inline ::tensorflow::data::FinishTaskUpdate* Update::release_finish_task() {
  // @@protoc_insertion_point(field_release:tensorflow.data.Update.finish_task)
  if (_internal_has_finish_task()) {
    clear_has_update_type();
      ::tensorflow::data::FinishTaskUpdate* temp = update_type_.finish_task_;
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    update_type_.finish_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::tensorflow::data::FinishTaskUpdate& Update::_internal_finish_task() const {
  return _internal_has_finish_task()
      ? *update_type_.finish_task_
      : reinterpret_cast< ::tensorflow::data::FinishTaskUpdate&>(::tensorflow::data::_FinishTaskUpdate_default_instance_);
}
inline const ::tensorflow::data::FinishTaskUpdate& Update::finish_task() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.Update.finish_task)
  return _internal_finish_task();
}
inline ::tensorflow::data::FinishTaskUpdate* Update::unsafe_arena_release_finish_task() {
  // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.data.Update.finish_task)
  if (_internal_has_finish_task()) {
    clear_has_update_type();
    ::tensorflow::data::FinishTaskUpdate* temp = update_type_.finish_task_;
    update_type_.finish_task_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Update::unsafe_arena_set_allocated_finish_task(::tensorflow::data::FinishTaskUpdate* finish_task) {
  clear_update_type();
  if (finish_task) {
    set_has_finish_task();
    update_type_.finish_task_ = finish_task;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.Update.finish_task)
}
inline ::tensorflow::data::FinishTaskUpdate* Update::_internal_mutable_finish_task() {
  if (!_internal_has_finish_task()) {
    clear_update_type();
    set_has_finish_task();
    update_type_.finish_task_ = CreateMaybeMessage< ::tensorflow::data::FinishTaskUpdate >(GetArenaForAllocation());
  }
  return update_type_.finish_task_;
}
inline ::tensorflow::data::FinishTaskUpdate* Update::mutable_finish_task() {
  ::tensorflow::data::FinishTaskUpdate* _msg = _internal_mutable_finish_task();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.Update.finish_task)
  return _msg;
}

inline bool Update::has_update_type() const {
  return update_type_case() != UPDATE_TYPE_NOT_SET;
}
inline void Update::clear_has_update_type() {
  _oneof_case_[0] = UPDATE_TYPE_NOT_SET;
}
inline Update::UpdateTypeCase Update::update_type_case() const {
  return Update::UpdateTypeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// RegisterDatasetUpdate

// int64 dataset_id = 1;
inline void RegisterDatasetUpdate::clear_dataset_id() {
  dataset_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RegisterDatasetUpdate::_internal_dataset_id() const {
  return dataset_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RegisterDatasetUpdate::dataset_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.RegisterDatasetUpdate.dataset_id)
  return _internal_dataset_id();
}
inline void RegisterDatasetUpdate::_internal_set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  dataset_id_ = value;
}
inline void RegisterDatasetUpdate::set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_dataset_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.RegisterDatasetUpdate.dataset_id)
}

// uint64 fingerprint = 2;
inline void RegisterDatasetUpdate::clear_fingerprint() {
  fingerprint_ = uint64_t{0u};
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 RegisterDatasetUpdate::_internal_fingerprint() const {
  return fingerprint_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint64 RegisterDatasetUpdate::fingerprint() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.RegisterDatasetUpdate.fingerprint)
  return _internal_fingerprint();
}
inline void RegisterDatasetUpdate::_internal_set_fingerprint(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  
  fingerprint_ = value;
}
inline void RegisterDatasetUpdate::set_fingerprint(::PROTOBUF_NAMESPACE_ID::uint64 value) {
  _internal_set_fingerprint(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.RegisterDatasetUpdate.fingerprint)
}

// -------------------------------------------------------------------

// RegisterWorkerUpdate

// string worker_address = 1;
inline void RegisterWorkerUpdate::clear_worker_address() {
  worker_address_.ClearToEmpty();
}
inline const std::string& RegisterWorkerUpdate::worker_address() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.RegisterWorkerUpdate.worker_address)
  return _internal_worker_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RegisterWorkerUpdate::set_worker_address(ArgT0&& arg0, ArgT... args) {
 
 worker_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.RegisterWorkerUpdate.worker_address)
}
inline std::string* RegisterWorkerUpdate::mutable_worker_address() {
  std::string* _s = _internal_mutable_worker_address();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.RegisterWorkerUpdate.worker_address)
  return _s;
}
inline const std::string& RegisterWorkerUpdate::_internal_worker_address() const {
  return worker_address_.Get();
}
inline void RegisterWorkerUpdate::_internal_set_worker_address(const std::string& value) {
  
  worker_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RegisterWorkerUpdate::_internal_mutable_worker_address() {
  
  return worker_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RegisterWorkerUpdate::release_worker_address() {
  // @@protoc_insertion_point(field_release:tensorflow.data.RegisterWorkerUpdate.worker_address)
  return worker_address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RegisterWorkerUpdate::set_allocated_worker_address(std::string* worker_address) {
  if (worker_address != nullptr) {
    
  } else {
    
  }
  worker_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), worker_address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.RegisterWorkerUpdate.worker_address)
}

// string transfer_address = 2;
inline void RegisterWorkerUpdate::clear_transfer_address() {
  transfer_address_.ClearToEmpty();
}
inline const std::string& RegisterWorkerUpdate::transfer_address() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.RegisterWorkerUpdate.transfer_address)
  return _internal_transfer_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void RegisterWorkerUpdate::set_transfer_address(ArgT0&& arg0, ArgT... args) {
 
 transfer_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.RegisterWorkerUpdate.transfer_address)
}
inline std::string* RegisterWorkerUpdate::mutable_transfer_address() {
  std::string* _s = _internal_mutable_transfer_address();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.RegisterWorkerUpdate.transfer_address)
  return _s;
}
inline const std::string& RegisterWorkerUpdate::_internal_transfer_address() const {
  return transfer_address_.Get();
}
inline void RegisterWorkerUpdate::_internal_set_transfer_address(const std::string& value) {
  
  transfer_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* RegisterWorkerUpdate::_internal_mutable_transfer_address() {
  
  return transfer_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* RegisterWorkerUpdate::release_transfer_address() {
  // @@protoc_insertion_point(field_release:tensorflow.data.RegisterWorkerUpdate.transfer_address)
  return transfer_address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void RegisterWorkerUpdate::set_allocated_transfer_address(std::string* transfer_address) {
  if (transfer_address != nullptr) {
    
  } else {
    
  }
  transfer_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), transfer_address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.RegisterWorkerUpdate.transfer_address)
}

// -------------------------------------------------------------------

// NamedJobKeyDef

// string name = 1;
inline void NamedJobKeyDef::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& NamedJobKeyDef::name() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.NamedJobKeyDef.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void NamedJobKeyDef::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.NamedJobKeyDef.name)
}
inline std::string* NamedJobKeyDef::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.NamedJobKeyDef.name)
  return _s;
}
inline const std::string& NamedJobKeyDef::_internal_name() const {
  return name_.Get();
}
inline void NamedJobKeyDef::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* NamedJobKeyDef::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* NamedJobKeyDef::release_name() {
  // @@protoc_insertion_point(field_release:tensorflow.data.NamedJobKeyDef.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void NamedJobKeyDef::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.NamedJobKeyDef.name)
}

// int64 index = 2;
inline void NamedJobKeyDef::clear_index() {
  index_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 NamedJobKeyDef::_internal_index() const {
  return index_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 NamedJobKeyDef::index() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.NamedJobKeyDef.index)
  return _internal_index();
}
inline void NamedJobKeyDef::_internal_set_index(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  index_ = value;
}
inline void NamedJobKeyDef::set_index(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_index(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.NamedJobKeyDef.index)
}

// -------------------------------------------------------------------

// CreateJobUpdate

// int64 job_id = 1;
inline void CreateJobUpdate::clear_job_id() {
  job_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::_internal_job_id() const {
  return job_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::job_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateJobUpdate.job_id)
  return _internal_job_id();
}
inline void CreateJobUpdate::_internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_id_ = value;
}
inline void CreateJobUpdate::set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateJobUpdate.job_id)
}

// int64 dataset_id = 2;
inline void CreateJobUpdate::clear_dataset_id() {
  dataset_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::_internal_dataset_id() const {
  return dataset_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::dataset_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateJobUpdate.dataset_id)
  return _internal_dataset_id();
}
inline void CreateJobUpdate::_internal_set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  dataset_id_ = value;
}
inline void CreateJobUpdate::set_dataset_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_dataset_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateJobUpdate.dataset_id)
}

// .tensorflow.data.ProcessingModeDef processing_mode = 3;
inline void CreateJobUpdate::clear_processing_mode() {
  processing_mode_ = 0;
}
inline ::tensorflow::data::ProcessingModeDef CreateJobUpdate::_internal_processing_mode() const {
  return static_cast< ::tensorflow::data::ProcessingModeDef >(processing_mode_);
}
inline ::tensorflow::data::ProcessingModeDef CreateJobUpdate::processing_mode() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateJobUpdate.processing_mode)
  return _internal_processing_mode();
}
inline void CreateJobUpdate::_internal_set_processing_mode(::tensorflow::data::ProcessingModeDef value) {
  
  processing_mode_ = value;
}
inline void CreateJobUpdate::set_processing_mode(::tensorflow::data::ProcessingModeDef value) {
  _internal_set_processing_mode(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateJobUpdate.processing_mode)
}

// int64 num_split_providers = 8;
inline void CreateJobUpdate::clear_num_split_providers() {
  num_split_providers_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::_internal_num_split_providers() const {
  return num_split_providers_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::num_split_providers() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateJobUpdate.num_split_providers)
  return _internal_num_split_providers();
}
inline void CreateJobUpdate::_internal_set_num_split_providers(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  num_split_providers_ = value;
}
inline void CreateJobUpdate::set_num_split_providers(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_num_split_providers(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateJobUpdate.num_split_providers)
}

// .tensorflow.data.NamedJobKeyDef named_job_key = 4;
inline bool CreateJobUpdate::_internal_has_named_job_key() const {
  return this != internal_default_instance() && named_job_key_ != nullptr;
}
inline bool CreateJobUpdate::has_named_job_key() const {
  return _internal_has_named_job_key();
}
inline void CreateJobUpdate::clear_named_job_key() {
  if (GetArenaForAllocation() == nullptr && named_job_key_ != nullptr) {
    delete named_job_key_;
  }
  named_job_key_ = nullptr;
}
inline const ::tensorflow::data::NamedJobKeyDef& CreateJobUpdate::_internal_named_job_key() const {
  const ::tensorflow::data::NamedJobKeyDef* p = named_job_key_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::NamedJobKeyDef&>(
      ::tensorflow::data::_NamedJobKeyDef_default_instance_);
}
inline const ::tensorflow::data::NamedJobKeyDef& CreateJobUpdate::named_job_key() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateJobUpdate.named_job_key)
  return _internal_named_job_key();
}
inline void CreateJobUpdate::unsafe_arena_set_allocated_named_job_key(
    ::tensorflow::data::NamedJobKeyDef* named_job_key) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(named_job_key_);
  }
  named_job_key_ = named_job_key;
  if (named_job_key) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.CreateJobUpdate.named_job_key)
}
inline ::tensorflow::data::NamedJobKeyDef* CreateJobUpdate::release_named_job_key() {
  
  ::tensorflow::data::NamedJobKeyDef* temp = named_job_key_;
  named_job_key_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::data::NamedJobKeyDef* CreateJobUpdate::unsafe_arena_release_named_job_key() {
  // @@protoc_insertion_point(field_release:tensorflow.data.CreateJobUpdate.named_job_key)
  
  ::tensorflow::data::NamedJobKeyDef* temp = named_job_key_;
  named_job_key_ = nullptr;
  return temp;
}
inline ::tensorflow::data::NamedJobKeyDef* CreateJobUpdate::_internal_mutable_named_job_key() {
  
  if (named_job_key_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::data::NamedJobKeyDef>(GetArenaForAllocation());
    named_job_key_ = p;
  }
  return named_job_key_;
}
inline ::tensorflow::data::NamedJobKeyDef* CreateJobUpdate::mutable_named_job_key() {
  ::tensorflow::data::NamedJobKeyDef* _msg = _internal_mutable_named_job_key();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.CreateJobUpdate.named_job_key)
  return _msg;
}
inline void CreateJobUpdate::set_allocated_named_job_key(::tensorflow::data::NamedJobKeyDef* named_job_key) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete named_job_key_;
  }
  if (named_job_key) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::data::NamedJobKeyDef>::GetOwningArena(named_job_key);
    if (message_arena != submessage_arena) {
      named_job_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, named_job_key, submessage_arena);
    }
    
  } else {
    
  }
  named_job_key_ = named_job_key;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CreateJobUpdate.named_job_key)
}

// int64 num_consumers = 7;
inline bool CreateJobUpdate::_internal_has_num_consumers() const {
  return optional_num_consumers_case() == kNumConsumers;
}
inline bool CreateJobUpdate::has_num_consumers() const {
  return _internal_has_num_consumers();
}
inline void CreateJobUpdate::set_has_num_consumers() {
  _oneof_case_[0] = kNumConsumers;
}
inline void CreateJobUpdate::clear_num_consumers() {
  if (_internal_has_num_consumers()) {
    optional_num_consumers_.num_consumers_ = int64_t{0};
    clear_has_optional_num_consumers();
  }
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::_internal_num_consumers() const {
  if (_internal_has_num_consumers()) {
    return optional_num_consumers_.num_consumers_;
  }
  return int64_t{0};
}
inline void CreateJobUpdate::_internal_set_num_consumers(::PROTOBUF_NAMESPACE_ID::int64 value) {
  if (!_internal_has_num_consumers()) {
    clear_optional_num_consumers();
    set_has_num_consumers();
  }
  optional_num_consumers_.num_consumers_ = value;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateJobUpdate::num_consumers() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateJobUpdate.num_consumers)
  return _internal_num_consumers();
}
inline void CreateJobUpdate::set_num_consumers(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_num_consumers(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateJobUpdate.num_consumers)
}

inline bool CreateJobUpdate::has_optional_num_consumers() const {
  return optional_num_consumers_case() != OPTIONAL_NUM_CONSUMERS_NOT_SET;
}
inline void CreateJobUpdate::clear_has_optional_num_consumers() {
  _oneof_case_[0] = OPTIONAL_NUM_CONSUMERS_NOT_SET;
}
inline CreateJobUpdate::OptionalNumConsumersCase CreateJobUpdate::optional_num_consumers_case() const {
  return CreateJobUpdate::OptionalNumConsumersCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// ProduceSplitUpdate

// int64 job_id = 1;
inline void ProduceSplitUpdate::clear_job_id() {
  job_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ProduceSplitUpdate::_internal_job_id() const {
  return job_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ProduceSplitUpdate::job_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ProduceSplitUpdate.job_id)
  return _internal_job_id();
}
inline void ProduceSplitUpdate::_internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_id_ = value;
}
inline void ProduceSplitUpdate::set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ProduceSplitUpdate.job_id)
}

// int64 repetition = 2;
inline void ProduceSplitUpdate::clear_repetition() {
  repetition_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ProduceSplitUpdate::_internal_repetition() const {
  return repetition_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ProduceSplitUpdate::repetition() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ProduceSplitUpdate.repetition)
  return _internal_repetition();
}
inline void ProduceSplitUpdate::_internal_set_repetition(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  repetition_ = value;
}
inline void ProduceSplitUpdate::set_repetition(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_repetition(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ProduceSplitUpdate.repetition)
}

// int64 split_provider_index = 4;
inline void ProduceSplitUpdate::clear_split_provider_index() {
  split_provider_index_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ProduceSplitUpdate::_internal_split_provider_index() const {
  return split_provider_index_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ProduceSplitUpdate::split_provider_index() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ProduceSplitUpdate.split_provider_index)
  return _internal_split_provider_index();
}
inline void ProduceSplitUpdate::_internal_set_split_provider_index(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  split_provider_index_ = value;
}
inline void ProduceSplitUpdate::set_split_provider_index(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_split_provider_index(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ProduceSplitUpdate.split_provider_index)
}

// bool finished = 3;
inline void ProduceSplitUpdate::clear_finished() {
  finished_ = false;
}
inline bool ProduceSplitUpdate::_internal_finished() const {
  return finished_;
}
inline bool ProduceSplitUpdate::finished() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ProduceSplitUpdate.finished)
  return _internal_finished();
}
inline void ProduceSplitUpdate::_internal_set_finished(bool value) {
  
  finished_ = value;
}
inline void ProduceSplitUpdate::set_finished(bool value) {
  _internal_set_finished(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ProduceSplitUpdate.finished)
}

// -------------------------------------------------------------------

// AcquireJobClientUpdate

// int64 job_id = 1;
inline void AcquireJobClientUpdate::clear_job_id() {
  job_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AcquireJobClientUpdate::_internal_job_id() const {
  return job_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AcquireJobClientUpdate::job_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.AcquireJobClientUpdate.job_id)
  return _internal_job_id();
}
inline void AcquireJobClientUpdate::_internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_id_ = value;
}
inline void AcquireJobClientUpdate::set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.AcquireJobClientUpdate.job_id)
}

// int64 job_client_id = 2;
inline void AcquireJobClientUpdate::clear_job_client_id() {
  job_client_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AcquireJobClientUpdate::_internal_job_client_id() const {
  return job_client_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 AcquireJobClientUpdate::job_client_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.AcquireJobClientUpdate.job_client_id)
  return _internal_job_client_id();
}
inline void AcquireJobClientUpdate::_internal_set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_client_id_ = value;
}
inline void AcquireJobClientUpdate::set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_client_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.AcquireJobClientUpdate.job_client_id)
}

// -------------------------------------------------------------------

// ReleaseJobClientUpdate

// int64 job_client_id = 1;
inline void ReleaseJobClientUpdate::clear_job_client_id() {
  job_client_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ReleaseJobClientUpdate::_internal_job_client_id() const {
  return job_client_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ReleaseJobClientUpdate::job_client_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ReleaseJobClientUpdate.job_client_id)
  return _internal_job_client_id();
}
inline void ReleaseJobClientUpdate::_internal_set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_client_id_ = value;
}
inline void ReleaseJobClientUpdate::set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_client_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ReleaseJobClientUpdate.job_client_id)
}

// int64 time_micros = 2;
inline void ReleaseJobClientUpdate::clear_time_micros() {
  time_micros_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ReleaseJobClientUpdate::_internal_time_micros() const {
  return time_micros_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ReleaseJobClientUpdate::time_micros() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ReleaseJobClientUpdate.time_micros)
  return _internal_time_micros();
}
inline void ReleaseJobClientUpdate::_internal_set_time_micros(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  time_micros_ = value;
}
inline void ReleaseJobClientUpdate::set_time_micros(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_time_micros(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ReleaseJobClientUpdate.time_micros)
}

// -------------------------------------------------------------------

// GarbageCollectJobUpdate

// int64 job_id = 1;
inline void GarbageCollectJobUpdate::clear_job_id() {
  job_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GarbageCollectJobUpdate::_internal_job_id() const {
  return job_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GarbageCollectJobUpdate::job_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.GarbageCollectJobUpdate.job_id)
  return _internal_job_id();
}
inline void GarbageCollectJobUpdate::_internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_id_ = value;
}
inline void GarbageCollectJobUpdate::set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.GarbageCollectJobUpdate.job_id)
}

// -------------------------------------------------------------------

// RemoveTaskUpdate

// int64 task_id = 1;
inline void RemoveTaskUpdate::clear_task_id() {
  task_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RemoveTaskUpdate::_internal_task_id() const {
  return task_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 RemoveTaskUpdate::task_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.RemoveTaskUpdate.task_id)
  return _internal_task_id();
}
inline void RemoveTaskUpdate::_internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  task_id_ = value;
}
inline void RemoveTaskUpdate::set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_task_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.RemoveTaskUpdate.task_id)
}

// -------------------------------------------------------------------

// TaskRejected

// int64 new_target_round = 1;
inline void TaskRejected::clear_new_target_round() {
  new_target_round_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TaskRejected::_internal_new_target_round() const {
  return new_target_round_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TaskRejected::new_target_round() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.TaskRejected.new_target_round)
  return _internal_new_target_round();
}
inline void TaskRejected::_internal_set_new_target_round(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  new_target_round_ = value;
}
inline void TaskRejected::set_new_target_round(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_new_target_round(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.TaskRejected.new_target_round)
}

// -------------------------------------------------------------------

// ClientHeartbeatUpdate

// int64 job_client_id = 1;
inline void ClientHeartbeatUpdate::clear_job_client_id() {
  job_client_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ClientHeartbeatUpdate::_internal_job_client_id() const {
  return job_client_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 ClientHeartbeatUpdate::job_client_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ClientHeartbeatUpdate.job_client_id)
  return _internal_job_client_id();
}
inline void ClientHeartbeatUpdate::_internal_set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_client_id_ = value;
}
inline void ClientHeartbeatUpdate::set_job_client_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_client_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ClientHeartbeatUpdate.job_client_id)
}

// bool task_accepted = 2;
inline void ClientHeartbeatUpdate::clear_task_accepted() {
  task_accepted_ = false;
}
inline bool ClientHeartbeatUpdate::_internal_task_accepted() const {
  return task_accepted_;
}
inline bool ClientHeartbeatUpdate::task_accepted() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ClientHeartbeatUpdate.task_accepted)
  return _internal_task_accepted();
}
inline void ClientHeartbeatUpdate::_internal_set_task_accepted(bool value) {
  
  task_accepted_ = value;
}
inline void ClientHeartbeatUpdate::set_task_accepted(bool value) {
  _internal_set_task_accepted(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.ClientHeartbeatUpdate.task_accepted)
}

// .tensorflow.data.TaskRejected task_rejected = 3;
inline bool ClientHeartbeatUpdate::_internal_has_task_rejected() const {
  return this != internal_default_instance() && task_rejected_ != nullptr;
}
inline bool ClientHeartbeatUpdate::has_task_rejected() const {
  return _internal_has_task_rejected();
}
inline void ClientHeartbeatUpdate::clear_task_rejected() {
  if (GetArenaForAllocation() == nullptr && task_rejected_ != nullptr) {
    delete task_rejected_;
  }
  task_rejected_ = nullptr;
}
inline const ::tensorflow::data::TaskRejected& ClientHeartbeatUpdate::_internal_task_rejected() const {
  const ::tensorflow::data::TaskRejected* p = task_rejected_;
  return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::data::TaskRejected&>(
      ::tensorflow::data::_TaskRejected_default_instance_);
}
inline const ::tensorflow::data::TaskRejected& ClientHeartbeatUpdate::task_rejected() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.ClientHeartbeatUpdate.task_rejected)
  return _internal_task_rejected();
}
inline void ClientHeartbeatUpdate::unsafe_arena_set_allocated_task_rejected(
    ::tensorflow::data::TaskRejected* task_rejected) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(task_rejected_);
  }
  task_rejected_ = task_rejected;
  if (task_rejected) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.data.ClientHeartbeatUpdate.task_rejected)
}
inline ::tensorflow::data::TaskRejected* ClientHeartbeatUpdate::release_task_rejected() {
  
  ::tensorflow::data::TaskRejected* temp = task_rejected_;
  task_rejected_ = nullptr;
#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  if (GetArenaForAllocation() == nullptr) { delete old; }
#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
  if (GetArenaForAllocation() != nullptr) {
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
  }
#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
  return temp;
}
inline ::tensorflow::data::TaskRejected* ClientHeartbeatUpdate::unsafe_arena_release_task_rejected() {
  // @@protoc_insertion_point(field_release:tensorflow.data.ClientHeartbeatUpdate.task_rejected)
  
  ::tensorflow::data::TaskRejected* temp = task_rejected_;
  task_rejected_ = nullptr;
  return temp;
}
inline ::tensorflow::data::TaskRejected* ClientHeartbeatUpdate::_internal_mutable_task_rejected() {
  
  if (task_rejected_ == nullptr) {
    auto* p = CreateMaybeMessage<::tensorflow::data::TaskRejected>(GetArenaForAllocation());
    task_rejected_ = p;
  }
  return task_rejected_;
}
inline ::tensorflow::data::TaskRejected* ClientHeartbeatUpdate::mutable_task_rejected() {
  ::tensorflow::data::TaskRejected* _msg = _internal_mutable_task_rejected();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.ClientHeartbeatUpdate.task_rejected)
  return _msg;
}
inline void ClientHeartbeatUpdate::set_allocated_task_rejected(::tensorflow::data::TaskRejected* task_rejected) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete task_rejected_;
  }
  if (task_rejected) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::tensorflow::data::TaskRejected>::GetOwningArena(task_rejected);
    if (message_arena != submessage_arena) {
      task_rejected = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, task_rejected, submessage_arena);
    }
    
  } else {
    
  }
  task_rejected_ = task_rejected;
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.ClientHeartbeatUpdate.task_rejected)
}

// -------------------------------------------------------------------

// CreatePendingTaskUpdate

// int64 task_id = 1;
inline void CreatePendingTaskUpdate::clear_task_id() {
  task_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreatePendingTaskUpdate::_internal_task_id() const {
  return task_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreatePendingTaskUpdate::task_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreatePendingTaskUpdate.task_id)
  return _internal_task_id();
}
inline void CreatePendingTaskUpdate::_internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  task_id_ = value;
}
inline void CreatePendingTaskUpdate::set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_task_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreatePendingTaskUpdate.task_id)
}

// int64 job_id = 2;
inline void CreatePendingTaskUpdate::clear_job_id() {
  job_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreatePendingTaskUpdate::_internal_job_id() const {
  return job_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreatePendingTaskUpdate::job_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreatePendingTaskUpdate.job_id)
  return _internal_job_id();
}
inline void CreatePendingTaskUpdate::_internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_id_ = value;
}
inline void CreatePendingTaskUpdate::set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreatePendingTaskUpdate.job_id)
}

// string worker_address = 3;
inline void CreatePendingTaskUpdate::clear_worker_address() {
  worker_address_.ClearToEmpty();
}
inline const std::string& CreatePendingTaskUpdate::worker_address() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreatePendingTaskUpdate.worker_address)
  return _internal_worker_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CreatePendingTaskUpdate::set_worker_address(ArgT0&& arg0, ArgT... args) {
 
 worker_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.CreatePendingTaskUpdate.worker_address)
}
inline std::string* CreatePendingTaskUpdate::mutable_worker_address() {
  std::string* _s = _internal_mutable_worker_address();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.CreatePendingTaskUpdate.worker_address)
  return _s;
}
inline const std::string& CreatePendingTaskUpdate::_internal_worker_address() const {
  return worker_address_.Get();
}
inline void CreatePendingTaskUpdate::_internal_set_worker_address(const std::string& value) {
  
  worker_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CreatePendingTaskUpdate::_internal_mutable_worker_address() {
  
  return worker_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CreatePendingTaskUpdate::release_worker_address() {
  // @@protoc_insertion_point(field_release:tensorflow.data.CreatePendingTaskUpdate.worker_address)
  return worker_address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CreatePendingTaskUpdate::set_allocated_worker_address(std::string* worker_address) {
  if (worker_address != nullptr) {
    
  } else {
    
  }
  worker_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), worker_address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CreatePendingTaskUpdate.worker_address)
}

// string transfer_address = 4;
inline void CreatePendingTaskUpdate::clear_transfer_address() {
  transfer_address_.ClearToEmpty();
}
inline const std::string& CreatePendingTaskUpdate::transfer_address() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreatePendingTaskUpdate.transfer_address)
  return _internal_transfer_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CreatePendingTaskUpdate::set_transfer_address(ArgT0&& arg0, ArgT... args) {
 
 transfer_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.CreatePendingTaskUpdate.transfer_address)
}
inline std::string* CreatePendingTaskUpdate::mutable_transfer_address() {
  std::string* _s = _internal_mutable_transfer_address();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.CreatePendingTaskUpdate.transfer_address)
  return _s;
}
inline const std::string& CreatePendingTaskUpdate::_internal_transfer_address() const {
  return transfer_address_.Get();
}
inline void CreatePendingTaskUpdate::_internal_set_transfer_address(const std::string& value) {
  
  transfer_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CreatePendingTaskUpdate::_internal_mutable_transfer_address() {
  
  return transfer_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CreatePendingTaskUpdate::release_transfer_address() {
  // @@protoc_insertion_point(field_release:tensorflow.data.CreatePendingTaskUpdate.transfer_address)
  return transfer_address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CreatePendingTaskUpdate::set_allocated_transfer_address(std::string* transfer_address) {
  if (transfer_address != nullptr) {
    
  } else {
    
  }
  transfer_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), transfer_address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CreatePendingTaskUpdate.transfer_address)
}

// int64 starting_round = 5;
inline void CreatePendingTaskUpdate::clear_starting_round() {
  starting_round_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreatePendingTaskUpdate::_internal_starting_round() const {
  return starting_round_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreatePendingTaskUpdate::starting_round() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreatePendingTaskUpdate.starting_round)
  return _internal_starting_round();
}
inline void CreatePendingTaskUpdate::_internal_set_starting_round(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  starting_round_ = value;
}
inline void CreatePendingTaskUpdate::set_starting_round(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_starting_round(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreatePendingTaskUpdate.starting_round)
}

// -------------------------------------------------------------------

// CreateTaskUpdate

// int64 task_id = 1;
inline void CreateTaskUpdate::clear_task_id() {
  task_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateTaskUpdate::_internal_task_id() const {
  return task_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateTaskUpdate::task_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateTaskUpdate.task_id)
  return _internal_task_id();
}
inline void CreateTaskUpdate::_internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  task_id_ = value;
}
inline void CreateTaskUpdate::set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_task_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateTaskUpdate.task_id)
}

// int64 job_id = 2;
inline void CreateTaskUpdate::clear_job_id() {
  job_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateTaskUpdate::_internal_job_id() const {
  return job_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 CreateTaskUpdate::job_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateTaskUpdate.job_id)
  return _internal_job_id();
}
inline void CreateTaskUpdate::_internal_set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  job_id_ = value;
}
inline void CreateTaskUpdate::set_job_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_job_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateTaskUpdate.job_id)
}

// string worker_address = 4;
inline void CreateTaskUpdate::clear_worker_address() {
  worker_address_.ClearToEmpty();
}
inline const std::string& CreateTaskUpdate::worker_address() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateTaskUpdate.worker_address)
  return _internal_worker_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CreateTaskUpdate::set_worker_address(ArgT0&& arg0, ArgT... args) {
 
 worker_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateTaskUpdate.worker_address)
}
inline std::string* CreateTaskUpdate::mutable_worker_address() {
  std::string* _s = _internal_mutable_worker_address();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.CreateTaskUpdate.worker_address)
  return _s;
}
inline const std::string& CreateTaskUpdate::_internal_worker_address() const {
  return worker_address_.Get();
}
inline void CreateTaskUpdate::_internal_set_worker_address(const std::string& value) {
  
  worker_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CreateTaskUpdate::_internal_mutable_worker_address() {
  
  return worker_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CreateTaskUpdate::release_worker_address() {
  // @@protoc_insertion_point(field_release:tensorflow.data.CreateTaskUpdate.worker_address)
  return worker_address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CreateTaskUpdate::set_allocated_worker_address(std::string* worker_address) {
  if (worker_address != nullptr) {
    
  } else {
    
  }
  worker_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), worker_address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CreateTaskUpdate.worker_address)
}

// string transfer_address = 6;
inline void CreateTaskUpdate::clear_transfer_address() {
  transfer_address_.ClearToEmpty();
}
inline const std::string& CreateTaskUpdate::transfer_address() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.CreateTaskUpdate.transfer_address)
  return _internal_transfer_address();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void CreateTaskUpdate::set_transfer_address(ArgT0&& arg0, ArgT... args) {
 
 transfer_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:tensorflow.data.CreateTaskUpdate.transfer_address)
}
inline std::string* CreateTaskUpdate::mutable_transfer_address() {
  std::string* _s = _internal_mutable_transfer_address();
  // @@protoc_insertion_point(field_mutable:tensorflow.data.CreateTaskUpdate.transfer_address)
  return _s;
}
inline const std::string& CreateTaskUpdate::_internal_transfer_address() const {
  return transfer_address_.Get();
}
inline void CreateTaskUpdate::_internal_set_transfer_address(const std::string& value) {
  
  transfer_address_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
}
inline std::string* CreateTaskUpdate::_internal_mutable_transfer_address() {
  
  return transfer_address_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
}
inline std::string* CreateTaskUpdate::release_transfer_address() {
  // @@protoc_insertion_point(field_release:tensorflow.data.CreateTaskUpdate.transfer_address)
  return transfer_address_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
}
inline void CreateTaskUpdate::set_allocated_transfer_address(std::string* transfer_address) {
  if (transfer_address != nullptr) {
    
  } else {
    
  }
  transfer_address_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), transfer_address,
      GetArenaForAllocation());
  // @@protoc_insertion_point(field_set_allocated:tensorflow.data.CreateTaskUpdate.transfer_address)
}

// -------------------------------------------------------------------

// FinishTaskUpdate

// int64 task_id = 1;
inline void FinishTaskUpdate::clear_task_id() {
  task_id_ = int64_t{0};
}
inline ::PROTOBUF_NAMESPACE_ID::int64 FinishTaskUpdate::_internal_task_id() const {
  return task_id_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 FinishTaskUpdate::task_id() const {
  // @@protoc_insertion_point(field_get:tensorflow.data.FinishTaskUpdate.task_id)
  return _internal_task_id();
}
inline void FinishTaskUpdate::_internal_set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  task_id_ = value;
}
inline void FinishTaskUpdate::set_task_id(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_task_id(value);
  // @@protoc_insertion_point(field_set:tensorflow.data.FinishTaskUpdate.task_id)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace data
}  // namespace tensorflow

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fdata_2fservice_2fjournal_2eproto
