1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/protobuf/coordination_service.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3009000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/generated_enum_reflection.h>
35#include <google/protobuf/unknown_field_set.h>
36#include "tensorflow/compiler/xla/pjrt/distributed/protocol.pb.h"
37#include "tensorflow/core/framework/device_attributes.pb.h"
38// @@protoc_insertion_point(includes)
39#include <google/protobuf/port_def.inc>
40#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto
41PROTOBUF_NAMESPACE_OPEN
42namespace internal {
43class AnyMetadata;
44} // namespace internal
45PROTOBUF_NAMESPACE_CLOSE
46
47// Internal implementation detail -- do not use these members.
48struct TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto {
49 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
50 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
52 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
53 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[34]
54 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
55 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
56 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
57 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
58};
59extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
60namespace tensorflow {
61class BarrierRequest;
62class BarrierRequestDefaultTypeInternal;
63extern BarrierRequestDefaultTypeInternal _BarrierRequest_default_instance_;
64class BarrierResponse;
65class BarrierResponseDefaultTypeInternal;
66extern BarrierResponseDefaultTypeInternal _BarrierResponse_default_instance_;
67class CancelBarrierRequest;
68class CancelBarrierRequestDefaultTypeInternal;
69extern CancelBarrierRequestDefaultTypeInternal _CancelBarrierRequest_default_instance_;
70class CancelBarrierResponse;
71class CancelBarrierResponseDefaultTypeInternal;
72extern CancelBarrierResponseDefaultTypeInternal _CancelBarrierResponse_default_instance_;
73class CoordinatedTask;
74class CoordinatedTaskDefaultTypeInternal;
75extern CoordinatedTaskDefaultTypeInternal _CoordinatedTask_default_instance_;
76class CoordinationServiceDeviceInfo;
77class CoordinationServiceDeviceInfoDefaultTypeInternal;
78extern CoordinationServiceDeviceInfoDefaultTypeInternal _CoordinationServiceDeviceInfo_default_instance_;
79class CoordinationServiceError;
80class CoordinationServiceErrorDefaultTypeInternal;
81extern CoordinationServiceErrorDefaultTypeInternal _CoordinationServiceError_default_instance_;
82class DeleteKeyValueRequest;
83class DeleteKeyValueRequestDefaultTypeInternal;
84extern DeleteKeyValueRequestDefaultTypeInternal _DeleteKeyValueRequest_default_instance_;
85class DeleteKeyValueResponse;
86class DeleteKeyValueResponseDefaultTypeInternal;
87extern DeleteKeyValueResponseDefaultTypeInternal _DeleteKeyValueResponse_default_instance_;
88class GetKeyValueDirRequest;
89class GetKeyValueDirRequestDefaultTypeInternal;
90extern GetKeyValueDirRequestDefaultTypeInternal _GetKeyValueDirRequest_default_instance_;
91class GetKeyValueDirResponse;
92class GetKeyValueDirResponseDefaultTypeInternal;
93extern GetKeyValueDirResponseDefaultTypeInternal _GetKeyValueDirResponse_default_instance_;
94class GetKeyValueRequest;
95class GetKeyValueRequestDefaultTypeInternal;
96extern GetKeyValueRequestDefaultTypeInternal _GetKeyValueRequest_default_instance_;
97class GetKeyValueResponse;
98class GetKeyValueResponseDefaultTypeInternal;
99extern GetKeyValueResponseDefaultTypeInternal _GetKeyValueResponse_default_instance_;
100class HeartbeatRequest;
101class HeartbeatRequestDefaultTypeInternal;
102extern HeartbeatRequestDefaultTypeInternal _HeartbeatRequest_default_instance_;
103class HeartbeatResponse;
104class HeartbeatResponseDefaultTypeInternal;
105extern HeartbeatResponseDefaultTypeInternal _HeartbeatResponse_default_instance_;
106class InsertKeyValueRequest;
107class InsertKeyValueRequestDefaultTypeInternal;
108extern InsertKeyValueRequestDefaultTypeInternal _InsertKeyValueRequest_default_instance_;
109class InsertKeyValueResponse;
110class InsertKeyValueResponseDefaultTypeInternal;
111extern InsertKeyValueResponseDefaultTypeInternal _InsertKeyValueResponse_default_instance_;
112class KeyValueEntry;
113class KeyValueEntryDefaultTypeInternal;
114extern KeyValueEntryDefaultTypeInternal _KeyValueEntry_default_instance_;
115class RegisterTaskRequest;
116class RegisterTaskRequestDefaultTypeInternal;
117extern RegisterTaskRequestDefaultTypeInternal _RegisterTaskRequest_default_instance_;
118class RegisterTaskResponse;
119class RegisterTaskResponseDefaultTypeInternal;
120extern RegisterTaskResponseDefaultTypeInternal _RegisterTaskResponse_default_instance_;
121class ReportErrorToServiceRequest;
122class ReportErrorToServiceRequestDefaultTypeInternal;
123extern ReportErrorToServiceRequestDefaultTypeInternal _ReportErrorToServiceRequest_default_instance_;
124class ReportErrorToServiceResponse;
125class ReportErrorToServiceResponseDefaultTypeInternal;
126extern ReportErrorToServiceResponseDefaultTypeInternal _ReportErrorToServiceResponse_default_instance_;
127class ReportErrorToTaskRequest;
128class ReportErrorToTaskRequestDefaultTypeInternal;
129extern ReportErrorToTaskRequestDefaultTypeInternal _ReportErrorToTaskRequest_default_instance_;
130class ReportErrorToTaskResponse;
131class ReportErrorToTaskResponseDefaultTypeInternal;
132extern ReportErrorToTaskResponseDefaultTypeInternal _ReportErrorToTaskResponse_default_instance_;
133class ResetTaskRequest;
134class ResetTaskRequestDefaultTypeInternal;
135extern ResetTaskRequestDefaultTypeInternal _ResetTaskRequest_default_instance_;
136class ResetTaskResponse;
137class ResetTaskResponseDefaultTypeInternal;
138extern ResetTaskResponseDefaultTypeInternal _ResetTaskResponse_default_instance_;
139class ShutdownTaskRequest;
140class ShutdownTaskRequestDefaultTypeInternal;
141extern ShutdownTaskRequestDefaultTypeInternal _ShutdownTaskRequest_default_instance_;
142class ShutdownTaskResponse;
143class ShutdownTaskResponseDefaultTypeInternal;
144extern ShutdownTaskResponseDefaultTypeInternal _ShutdownTaskResponse_default_instance_;
145class TfDeviceList;
146class TfDeviceListDefaultTypeInternal;
147extern TfDeviceListDefaultTypeInternal _TfDeviceList_default_instance_;
148class TryGetKeyValueRequest;
149class TryGetKeyValueRequestDefaultTypeInternal;
150extern TryGetKeyValueRequestDefaultTypeInternal _TryGetKeyValueRequest_default_instance_;
151class TryGetKeyValueResponse;
152class TryGetKeyValueResponseDefaultTypeInternal;
153extern TryGetKeyValueResponseDefaultTypeInternal _TryGetKeyValueResponse_default_instance_;
154class WaitForAllTasksRequest;
155class WaitForAllTasksRequestDefaultTypeInternal;
156extern WaitForAllTasksRequestDefaultTypeInternal _WaitForAllTasksRequest_default_instance_;
157class WaitForAllTasksResponse;
158class WaitForAllTasksResponseDefaultTypeInternal;
159extern WaitForAllTasksResponseDefaultTypeInternal _WaitForAllTasksResponse_default_instance_;
160class XlaDeviceList;
161class XlaDeviceListDefaultTypeInternal;
162extern XlaDeviceListDefaultTypeInternal _XlaDeviceList_default_instance_;
163} // namespace tensorflow
164PROTOBUF_NAMESPACE_OPEN
165template<> ::tensorflow::BarrierRequest* Arena::CreateMaybeMessage<::tensorflow::BarrierRequest>(Arena*);
166template<> ::tensorflow::BarrierResponse* Arena::CreateMaybeMessage<::tensorflow::BarrierResponse>(Arena*);
167template<> ::tensorflow::CancelBarrierRequest* Arena::CreateMaybeMessage<::tensorflow::CancelBarrierRequest>(Arena*);
168template<> ::tensorflow::CancelBarrierResponse* Arena::CreateMaybeMessage<::tensorflow::CancelBarrierResponse>(Arena*);
169template<> ::tensorflow::CoordinatedTask* Arena::CreateMaybeMessage<::tensorflow::CoordinatedTask>(Arena*);
170template<> ::tensorflow::CoordinationServiceDeviceInfo* Arena::CreateMaybeMessage<::tensorflow::CoordinationServiceDeviceInfo>(Arena*);
171template<> ::tensorflow::CoordinationServiceError* Arena::CreateMaybeMessage<::tensorflow::CoordinationServiceError>(Arena*);
172template<> ::tensorflow::DeleteKeyValueRequest* Arena::CreateMaybeMessage<::tensorflow::DeleteKeyValueRequest>(Arena*);
173template<> ::tensorflow::DeleteKeyValueResponse* Arena::CreateMaybeMessage<::tensorflow::DeleteKeyValueResponse>(Arena*);
174template<> ::tensorflow::GetKeyValueDirRequest* Arena::CreateMaybeMessage<::tensorflow::GetKeyValueDirRequest>(Arena*);
175template<> ::tensorflow::GetKeyValueDirResponse* Arena::CreateMaybeMessage<::tensorflow::GetKeyValueDirResponse>(Arena*);
176template<> ::tensorflow::GetKeyValueRequest* Arena::CreateMaybeMessage<::tensorflow::GetKeyValueRequest>(Arena*);
177template<> ::tensorflow::GetKeyValueResponse* Arena::CreateMaybeMessage<::tensorflow::GetKeyValueResponse>(Arena*);
178template<> ::tensorflow::HeartbeatRequest* Arena::CreateMaybeMessage<::tensorflow::HeartbeatRequest>(Arena*);
179template<> ::tensorflow::HeartbeatResponse* Arena::CreateMaybeMessage<::tensorflow::HeartbeatResponse>(Arena*);
180template<> ::tensorflow::InsertKeyValueRequest* Arena::CreateMaybeMessage<::tensorflow::InsertKeyValueRequest>(Arena*);
181template<> ::tensorflow::InsertKeyValueResponse* Arena::CreateMaybeMessage<::tensorflow::InsertKeyValueResponse>(Arena*);
182template<> ::tensorflow::KeyValueEntry* Arena::CreateMaybeMessage<::tensorflow::KeyValueEntry>(Arena*);
183template<> ::tensorflow::RegisterTaskRequest* Arena::CreateMaybeMessage<::tensorflow::RegisterTaskRequest>(Arena*);
184template<> ::tensorflow::RegisterTaskResponse* Arena::CreateMaybeMessage<::tensorflow::RegisterTaskResponse>(Arena*);
185template<> ::tensorflow::ReportErrorToServiceRequest* Arena::CreateMaybeMessage<::tensorflow::ReportErrorToServiceRequest>(Arena*);
186template<> ::tensorflow::ReportErrorToServiceResponse* Arena::CreateMaybeMessage<::tensorflow::ReportErrorToServiceResponse>(Arena*);
187template<> ::tensorflow::ReportErrorToTaskRequest* Arena::CreateMaybeMessage<::tensorflow::ReportErrorToTaskRequest>(Arena*);
188template<> ::tensorflow::ReportErrorToTaskResponse* Arena::CreateMaybeMessage<::tensorflow::ReportErrorToTaskResponse>(Arena*);
189template<> ::tensorflow::ResetTaskRequest* Arena::CreateMaybeMessage<::tensorflow::ResetTaskRequest>(Arena*);
190template<> ::tensorflow::ResetTaskResponse* Arena::CreateMaybeMessage<::tensorflow::ResetTaskResponse>(Arena*);
191template<> ::tensorflow::ShutdownTaskRequest* Arena::CreateMaybeMessage<::tensorflow::ShutdownTaskRequest>(Arena*);
192template<> ::tensorflow::ShutdownTaskResponse* Arena::CreateMaybeMessage<::tensorflow::ShutdownTaskResponse>(Arena*);
193template<> ::tensorflow::TfDeviceList* Arena::CreateMaybeMessage<::tensorflow::TfDeviceList>(Arena*);
194template<> ::tensorflow::TryGetKeyValueRequest* Arena::CreateMaybeMessage<::tensorflow::TryGetKeyValueRequest>(Arena*);
195template<> ::tensorflow::TryGetKeyValueResponse* Arena::CreateMaybeMessage<::tensorflow::TryGetKeyValueResponse>(Arena*);
196template<> ::tensorflow::WaitForAllTasksRequest* Arena::CreateMaybeMessage<::tensorflow::WaitForAllTasksRequest>(Arena*);
197template<> ::tensorflow::WaitForAllTasksResponse* Arena::CreateMaybeMessage<::tensorflow::WaitForAllTasksResponse>(Arena*);
198template<> ::tensorflow::XlaDeviceList* Arena::CreateMaybeMessage<::tensorflow::XlaDeviceList>(Arena*);
199PROTOBUF_NAMESPACE_CLOSE
200namespace tensorflow {
201
202enum CoordinatedTaskState : int {
203 TASKSTATE_UNSPECIFIED = 0,
204 TASKSTATE_UNINITIALIZED = 1,
205 TASKSTATE_DISCONNECTED = 2,
206 TASKSTATE_CONNECTED = 3,
207 TASKSTATE_ERROR = 4,
208 CoordinatedTaskState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
209 CoordinatedTaskState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
210};
211bool CoordinatedTaskState_IsValid(int value);
212constexpr CoordinatedTaskState CoordinatedTaskState_MIN = TASKSTATE_UNSPECIFIED;
213constexpr CoordinatedTaskState CoordinatedTaskState_MAX = TASKSTATE_ERROR;
214constexpr int CoordinatedTaskState_ARRAYSIZE = CoordinatedTaskState_MAX + 1;
215
216const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CoordinatedTaskState_descriptor();
217template<typename T>
218inline const std::string& CoordinatedTaskState_Name(T enum_t_value) {
219 static_assert(::std::is_same<T, CoordinatedTaskState>::value ||
220 ::std::is_integral<T>::value,
221 "Incorrect type passed to function CoordinatedTaskState_Name.");
222 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
223 CoordinatedTaskState_descriptor(), enum_t_value);
224}
225inline bool CoordinatedTaskState_Parse(
226 const std::string& name, CoordinatedTaskState* value) {
227 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CoordinatedTaskState>(
228 CoordinatedTaskState_descriptor(), name, value);
229}
230// ===================================================================
231
232class CoordinatedTask :
233 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CoordinatedTask) */ {
234 public:
235 CoordinatedTask();
236 virtual ~CoordinatedTask();
237
238 CoordinatedTask(const CoordinatedTask& from);
239 CoordinatedTask(CoordinatedTask&& from) noexcept
240 : CoordinatedTask() {
241 *this = ::std::move(from);
242 }
243
244 inline CoordinatedTask& operator=(const CoordinatedTask& from) {
245 CopyFrom(from);
246 return *this;
247 }
248 inline CoordinatedTask& operator=(CoordinatedTask&& from) noexcept {
249 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
250 if (this != &from) InternalSwap(&from);
251 } else {
252 CopyFrom(from);
253 }
254 return *this;
255 }
256
257 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
258 return GetDescriptor();
259 }
260 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
261 return GetMetadataStatic().descriptor;
262 }
263 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
264 return GetMetadataStatic().reflection;
265 }
266 static const CoordinatedTask& default_instance();
267
268 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
269 static inline const CoordinatedTask* internal_default_instance() {
270 return reinterpret_cast<const CoordinatedTask*>(
271 &_CoordinatedTask_default_instance_);
272 }
273 static constexpr int kIndexInFileMessages =
274 0;
275
276 friend void swap(CoordinatedTask& a, CoordinatedTask& b) {
277 a.Swap(&b);
278 }
279 inline void Swap(CoordinatedTask* other) {
280 if (other == this) return;
281 InternalSwap(other);
282 }
283
284 // implements Message ----------------------------------------------
285
286 inline CoordinatedTask* New() const final {
287 return CreateMaybeMessage<CoordinatedTask>(nullptr);
288 }
289
290 CoordinatedTask* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
291 return CreateMaybeMessage<CoordinatedTask>(arena);
292 }
293 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
294 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
295 void CopyFrom(const CoordinatedTask& from);
296 void MergeFrom(const CoordinatedTask& from);
297 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
298 bool IsInitialized() const final;
299
300 size_t ByteSizeLong() const final;
301 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
302 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
303 #else
304 bool MergePartialFromCodedStream(
305 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
306 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
307 void SerializeWithCachedSizes(
308 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
309 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
310 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
311 int GetCachedSize() const final { return _cached_size_.Get(); }
312
313 private:
314 inline void SharedCtor();
315 inline void SharedDtor();
316 void SetCachedSize(int size) const final;
317 void InternalSwap(CoordinatedTask* other);
318 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
319 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
320 return "tensorflow.CoordinatedTask";
321 }
322 private:
323 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
324 return nullptr;
325 }
326 inline void* MaybeArenaPtr() const {
327 return nullptr;
328 }
329 public:
330
331 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
332 private:
333 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
334 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
335 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
336 }
337
338 public:
339
340 // nested types ----------------------------------------------------
341
342 // accessors -------------------------------------------------------
343
344 enum : int {
345 kJobNameFieldNumber = 1,
346 kTaskIdFieldNumber = 2,
347 };
348 // string job_name = 1;
349 void clear_job_name();
350 const std::string& job_name() const;
351 void set_job_name(const std::string& value);
352 void set_job_name(std::string&& value);
353 void set_job_name(const char* value);
354 void set_job_name(const char* value, size_t size);
355 std::string* mutable_job_name();
356 std::string* release_job_name();
357 void set_allocated_job_name(std::string* job_name);
358
359 // int32 task_id = 2;
360 void clear_task_id();
361 ::PROTOBUF_NAMESPACE_ID::int32 task_id() const;
362 void set_task_id(::PROTOBUF_NAMESPACE_ID::int32 value);
363
364 // @@protoc_insertion_point(class_scope:tensorflow.CoordinatedTask)
365 private:
366 class _Internal;
367
368 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
369 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr job_name_;
370 ::PROTOBUF_NAMESPACE_ID::int32 task_id_;
371 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
372 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
373};
374// -------------------------------------------------------------------
375
376class CoordinationServiceError :
377 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CoordinationServiceError) */ {
378 public:
379 CoordinationServiceError();
380 virtual ~CoordinationServiceError();
381
382 CoordinationServiceError(const CoordinationServiceError& from);
383 CoordinationServiceError(CoordinationServiceError&& from) noexcept
384 : CoordinationServiceError() {
385 *this = ::std::move(from);
386 }
387
388 inline CoordinationServiceError& operator=(const CoordinationServiceError& from) {
389 CopyFrom(from);
390 return *this;
391 }
392 inline CoordinationServiceError& operator=(CoordinationServiceError&& from) noexcept {
393 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
394 if (this != &from) InternalSwap(&from);
395 } else {
396 CopyFrom(from);
397 }
398 return *this;
399 }
400
401 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
402 return GetDescriptor();
403 }
404 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
405 return GetMetadataStatic().descriptor;
406 }
407 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
408 return GetMetadataStatic().reflection;
409 }
410 static const CoordinationServiceError& default_instance();
411
412 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
413 static inline const CoordinationServiceError* internal_default_instance() {
414 return reinterpret_cast<const CoordinationServiceError*>(
415 &_CoordinationServiceError_default_instance_);
416 }
417 static constexpr int kIndexInFileMessages =
418 1;
419
420 friend void swap(CoordinationServiceError& a, CoordinationServiceError& b) {
421 a.Swap(&b);
422 }
423 inline void Swap(CoordinationServiceError* other) {
424 if (other == this) return;
425 InternalSwap(other);
426 }
427
428 // implements Message ----------------------------------------------
429
430 inline CoordinationServiceError* New() const final {
431 return CreateMaybeMessage<CoordinationServiceError>(nullptr);
432 }
433
434 CoordinationServiceError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
435 return CreateMaybeMessage<CoordinationServiceError>(arena);
436 }
437 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
438 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
439 void CopyFrom(const CoordinationServiceError& from);
440 void MergeFrom(const CoordinationServiceError& from);
441 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
442 bool IsInitialized() const final;
443
444 size_t ByteSizeLong() const final;
445 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
446 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
447 #else
448 bool MergePartialFromCodedStream(
449 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
450 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
451 void SerializeWithCachedSizes(
452 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
453 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
454 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
455 int GetCachedSize() const final { return _cached_size_.Get(); }
456
457 private:
458 inline void SharedCtor();
459 inline void SharedDtor();
460 void SetCachedSize(int size) const final;
461 void InternalSwap(CoordinationServiceError* other);
462 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
463 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
464 return "tensorflow.CoordinationServiceError";
465 }
466 private:
467 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
468 return nullptr;
469 }
470 inline void* MaybeArenaPtr() const {
471 return nullptr;
472 }
473 public:
474
475 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
476 private:
477 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
478 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
479 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
480 }
481
482 public:
483
484 // nested types ----------------------------------------------------
485
486 // accessors -------------------------------------------------------
487
488 enum : int {
489 kSourceTaskFieldNumber = 4,
490 kIsReportedErrorFieldNumber = 3,
491 };
492 // .tensorflow.CoordinatedTask source_task = 4;
493 bool has_source_task() const;
494 void clear_source_task();
495 const ::tensorflow::CoordinatedTask& source_task() const;
496 ::tensorflow::CoordinatedTask* release_source_task();
497 ::tensorflow::CoordinatedTask* mutable_source_task();
498 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
499
500 // bool is_reported_error = 3;
501 void clear_is_reported_error();
502 bool is_reported_error() const;
503 void set_is_reported_error(bool value);
504
505 // @@protoc_insertion_point(class_scope:tensorflow.CoordinationServiceError)
506 private:
507 class _Internal;
508
509 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
510 ::tensorflow::CoordinatedTask* source_task_;
511 bool is_reported_error_;
512 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
513 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
514};
515// -------------------------------------------------------------------
516
517class TfDeviceList :
518 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TfDeviceList) */ {
519 public:
520 TfDeviceList();
521 virtual ~TfDeviceList();
522
523 TfDeviceList(const TfDeviceList& from);
524 TfDeviceList(TfDeviceList&& from) noexcept
525 : TfDeviceList() {
526 *this = ::std::move(from);
527 }
528
529 inline TfDeviceList& operator=(const TfDeviceList& from) {
530 CopyFrom(from);
531 return *this;
532 }
533 inline TfDeviceList& operator=(TfDeviceList&& from) noexcept {
534 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
535 if (this != &from) InternalSwap(&from);
536 } else {
537 CopyFrom(from);
538 }
539 return *this;
540 }
541
542 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
543 return GetDescriptor();
544 }
545 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
546 return GetMetadataStatic().descriptor;
547 }
548 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
549 return GetMetadataStatic().reflection;
550 }
551 static const TfDeviceList& default_instance();
552
553 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
554 static inline const TfDeviceList* internal_default_instance() {
555 return reinterpret_cast<const TfDeviceList*>(
556 &_TfDeviceList_default_instance_);
557 }
558 static constexpr int kIndexInFileMessages =
559 2;
560
561 friend void swap(TfDeviceList& a, TfDeviceList& b) {
562 a.Swap(&b);
563 }
564 inline void Swap(TfDeviceList* other) {
565 if (other == this) return;
566 InternalSwap(other);
567 }
568
569 // implements Message ----------------------------------------------
570
571 inline TfDeviceList* New() const final {
572 return CreateMaybeMessage<TfDeviceList>(nullptr);
573 }
574
575 TfDeviceList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
576 return CreateMaybeMessage<TfDeviceList>(arena);
577 }
578 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
579 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
580 void CopyFrom(const TfDeviceList& from);
581 void MergeFrom(const TfDeviceList& from);
582 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
583 bool IsInitialized() const final;
584
585 size_t ByteSizeLong() const final;
586 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
587 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
588 #else
589 bool MergePartialFromCodedStream(
590 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
591 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
592 void SerializeWithCachedSizes(
593 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
594 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
595 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
596 int GetCachedSize() const final { return _cached_size_.Get(); }
597
598 private:
599 inline void SharedCtor();
600 inline void SharedDtor();
601 void SetCachedSize(int size) const final;
602 void InternalSwap(TfDeviceList* other);
603 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
604 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
605 return "tensorflow.TfDeviceList";
606 }
607 private:
608 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
609 return nullptr;
610 }
611 inline void* MaybeArenaPtr() const {
612 return nullptr;
613 }
614 public:
615
616 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
617 private:
618 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
619 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
620 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
621 }
622
623 public:
624
625 // nested types ----------------------------------------------------
626
627 // accessors -------------------------------------------------------
628
629 enum : int {
630 kDevicesFieldNumber = 1,
631 };
632 // repeated .tensorflow.DeviceAttributes devices = 1;
633 int devices_size() const;
634 void clear_devices();
635 ::tensorflow::DeviceAttributes* mutable_devices(int index);
636 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
637 mutable_devices();
638 const ::tensorflow::DeviceAttributes& devices(int index) const;
639 ::tensorflow::DeviceAttributes* add_devices();
640 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
641 devices() const;
642
643 // @@protoc_insertion_point(class_scope:tensorflow.TfDeviceList)
644 private:
645 class _Internal;
646
647 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
648 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes > devices_;
649 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
650 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
651};
652// -------------------------------------------------------------------
653
654class XlaDeviceList :
655 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.XlaDeviceList) */ {
656 public:
657 XlaDeviceList();
658 virtual ~XlaDeviceList();
659
660 XlaDeviceList(const XlaDeviceList& from);
661 XlaDeviceList(XlaDeviceList&& from) noexcept
662 : XlaDeviceList() {
663 *this = ::std::move(from);
664 }
665
666 inline XlaDeviceList& operator=(const XlaDeviceList& from) {
667 CopyFrom(from);
668 return *this;
669 }
670 inline XlaDeviceList& operator=(XlaDeviceList&& from) noexcept {
671 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
672 if (this != &from) InternalSwap(&from);
673 } else {
674 CopyFrom(from);
675 }
676 return *this;
677 }
678
679 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
680 return GetDescriptor();
681 }
682 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
683 return GetMetadataStatic().descriptor;
684 }
685 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
686 return GetMetadataStatic().reflection;
687 }
688 static const XlaDeviceList& default_instance();
689
690 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
691 static inline const XlaDeviceList* internal_default_instance() {
692 return reinterpret_cast<const XlaDeviceList*>(
693 &_XlaDeviceList_default_instance_);
694 }
695 static constexpr int kIndexInFileMessages =
696 3;
697
698 friend void swap(XlaDeviceList& a, XlaDeviceList& b) {
699 a.Swap(&b);
700 }
701 inline void Swap(XlaDeviceList* other) {
702 if (other == this) return;
703 InternalSwap(other);
704 }
705
706 // implements Message ----------------------------------------------
707
708 inline XlaDeviceList* New() const final {
709 return CreateMaybeMessage<XlaDeviceList>(nullptr);
710 }
711
712 XlaDeviceList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
713 return CreateMaybeMessage<XlaDeviceList>(arena);
714 }
715 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
716 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
717 void CopyFrom(const XlaDeviceList& from);
718 void MergeFrom(const XlaDeviceList& from);
719 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
720 bool IsInitialized() const final;
721
722 size_t ByteSizeLong() const final;
723 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
724 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
725 #else
726 bool MergePartialFromCodedStream(
727 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
728 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
729 void SerializeWithCachedSizes(
730 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
731 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
732 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
733 int GetCachedSize() const final { return _cached_size_.Get(); }
734
735 private:
736 inline void SharedCtor();
737 inline void SharedDtor();
738 void SetCachedSize(int size) const final;
739 void InternalSwap(XlaDeviceList* other);
740 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
741 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
742 return "tensorflow.XlaDeviceList";
743 }
744 private:
745 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
746 return nullptr;
747 }
748 inline void* MaybeArenaPtr() const {
749 return nullptr;
750 }
751 public:
752
753 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
754 private:
755 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
756 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
757 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
758 }
759
760 public:
761
762 // nested types ----------------------------------------------------
763
764 // accessors -------------------------------------------------------
765
766 enum : int {
767 kDevicesFieldNumber = 1,
768 };
769 // .xla.GlobalTopologyProto devices = 1;
770 bool has_devices() const;
771 void clear_devices();
772 const ::xla::GlobalTopologyProto& devices() const;
773 ::xla::GlobalTopologyProto* release_devices();
774 ::xla::GlobalTopologyProto* mutable_devices();
775 void set_allocated_devices(::xla::GlobalTopologyProto* devices);
776
777 // @@protoc_insertion_point(class_scope:tensorflow.XlaDeviceList)
778 private:
779 class _Internal;
780
781 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
782 ::xla::GlobalTopologyProto* devices_;
783 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
784 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
785};
786// -------------------------------------------------------------------
787
788class CoordinationServiceDeviceInfo :
789 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CoordinationServiceDeviceInfo) */ {
790 public:
791 CoordinationServiceDeviceInfo();
792 virtual ~CoordinationServiceDeviceInfo();
793
794 CoordinationServiceDeviceInfo(const CoordinationServiceDeviceInfo& from);
795 CoordinationServiceDeviceInfo(CoordinationServiceDeviceInfo&& from) noexcept
796 : CoordinationServiceDeviceInfo() {
797 *this = ::std::move(from);
798 }
799
800 inline CoordinationServiceDeviceInfo& operator=(const CoordinationServiceDeviceInfo& from) {
801 CopyFrom(from);
802 return *this;
803 }
804 inline CoordinationServiceDeviceInfo& operator=(CoordinationServiceDeviceInfo&& from) noexcept {
805 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
806 if (this != &from) InternalSwap(&from);
807 } else {
808 CopyFrom(from);
809 }
810 return *this;
811 }
812
813 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
814 return GetDescriptor();
815 }
816 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
817 return GetMetadataStatic().descriptor;
818 }
819 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
820 return GetMetadataStatic().reflection;
821 }
822 static const CoordinationServiceDeviceInfo& default_instance();
823
824 enum TypeCase {
825 kTf = 1,
826 kXla = 2,
827 TYPE_NOT_SET = 0,
828 };
829
830 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
831 static inline const CoordinationServiceDeviceInfo* internal_default_instance() {
832 return reinterpret_cast<const CoordinationServiceDeviceInfo*>(
833 &_CoordinationServiceDeviceInfo_default_instance_);
834 }
835 static constexpr int kIndexInFileMessages =
836 4;
837
838 friend void swap(CoordinationServiceDeviceInfo& a, CoordinationServiceDeviceInfo& b) {
839 a.Swap(&b);
840 }
841 inline void Swap(CoordinationServiceDeviceInfo* other) {
842 if (other == this) return;
843 InternalSwap(other);
844 }
845
846 // implements Message ----------------------------------------------
847
848 inline CoordinationServiceDeviceInfo* New() const final {
849 return CreateMaybeMessage<CoordinationServiceDeviceInfo>(nullptr);
850 }
851
852 CoordinationServiceDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
853 return CreateMaybeMessage<CoordinationServiceDeviceInfo>(arena);
854 }
855 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
856 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
857 void CopyFrom(const CoordinationServiceDeviceInfo& from);
858 void MergeFrom(const CoordinationServiceDeviceInfo& from);
859 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
860 bool IsInitialized() const final;
861
862 size_t ByteSizeLong() const final;
863 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
864 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
865 #else
866 bool MergePartialFromCodedStream(
867 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
868 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
869 void SerializeWithCachedSizes(
870 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
871 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
872 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
873 int GetCachedSize() const final { return _cached_size_.Get(); }
874
875 private:
876 inline void SharedCtor();
877 inline void SharedDtor();
878 void SetCachedSize(int size) const final;
879 void InternalSwap(CoordinationServiceDeviceInfo* other);
880 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
881 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
882 return "tensorflow.CoordinationServiceDeviceInfo";
883 }
884 private:
885 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
886 return nullptr;
887 }
888 inline void* MaybeArenaPtr() const {
889 return nullptr;
890 }
891 public:
892
893 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
894 private:
895 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
896 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
897 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
898 }
899
900 public:
901
902 // nested types ----------------------------------------------------
903
904 // accessors -------------------------------------------------------
905
906 enum : int {
907 kTfFieldNumber = 1,
908 kXlaFieldNumber = 2,
909 };
910 // .tensorflow.TfDeviceList tf = 1;
911 bool has_tf() const;
912 void clear_tf();
913 const ::tensorflow::TfDeviceList& tf() const;
914 ::tensorflow::TfDeviceList* release_tf();
915 ::tensorflow::TfDeviceList* mutable_tf();
916 void set_allocated_tf(::tensorflow::TfDeviceList* tf);
917
918 // .tensorflow.XlaDeviceList xla = 2;
919 bool has_xla() const;
920 void clear_xla();
921 const ::tensorflow::XlaDeviceList& xla() const;
922 ::tensorflow::XlaDeviceList* release_xla();
923 ::tensorflow::XlaDeviceList* mutable_xla();
924 void set_allocated_xla(::tensorflow::XlaDeviceList* xla);
925
926 void clear_type();
927 TypeCase type_case() const;
928 // @@protoc_insertion_point(class_scope:tensorflow.CoordinationServiceDeviceInfo)
929 private:
930 class _Internal;
931 void set_has_tf();
932 void set_has_xla();
933
934 inline bool has_type() const;
935 inline void clear_has_type();
936
937 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
938 union TypeUnion {
939 TypeUnion() {}
940 ::tensorflow::TfDeviceList* tf_;
941 ::tensorflow::XlaDeviceList* xla_;
942 } type_;
943 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
944 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
945
946 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
947};
948// -------------------------------------------------------------------
949
950class RegisterTaskRequest :
951 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.RegisterTaskRequest) */ {
952 public:
953 RegisterTaskRequest();
954 virtual ~RegisterTaskRequest();
955
956 RegisterTaskRequest(const RegisterTaskRequest& from);
957 RegisterTaskRequest(RegisterTaskRequest&& from) noexcept
958 : RegisterTaskRequest() {
959 *this = ::std::move(from);
960 }
961
962 inline RegisterTaskRequest& operator=(const RegisterTaskRequest& from) {
963 CopyFrom(from);
964 return *this;
965 }
966 inline RegisterTaskRequest& operator=(RegisterTaskRequest&& from) noexcept {
967 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
968 if (this != &from) InternalSwap(&from);
969 } else {
970 CopyFrom(from);
971 }
972 return *this;
973 }
974
975 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
976 return GetDescriptor();
977 }
978 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
979 return GetMetadataStatic().descriptor;
980 }
981 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
982 return GetMetadataStatic().reflection;
983 }
984 static const RegisterTaskRequest& default_instance();
985
986 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
987 static inline const RegisterTaskRequest* internal_default_instance() {
988 return reinterpret_cast<const RegisterTaskRequest*>(
989 &_RegisterTaskRequest_default_instance_);
990 }
991 static constexpr int kIndexInFileMessages =
992 5;
993
994 friend void swap(RegisterTaskRequest& a, RegisterTaskRequest& b) {
995 a.Swap(&b);
996 }
997 inline void Swap(RegisterTaskRequest* other) {
998 if (other == this) return;
999 InternalSwap(other);
1000 }
1001
1002 // implements Message ----------------------------------------------
1003
1004 inline RegisterTaskRequest* New() const final {
1005 return CreateMaybeMessage<RegisterTaskRequest>(nullptr);
1006 }
1007
1008 RegisterTaskRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1009 return CreateMaybeMessage<RegisterTaskRequest>(arena);
1010 }
1011 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1012 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1013 void CopyFrom(const RegisterTaskRequest& from);
1014 void MergeFrom(const RegisterTaskRequest& from);
1015 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1016 bool IsInitialized() const final;
1017
1018 size_t ByteSizeLong() const final;
1019 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1020 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1021 #else
1022 bool MergePartialFromCodedStream(
1023 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1024 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1025 void SerializeWithCachedSizes(
1026 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1027 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1028 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1029 int GetCachedSize() const final { return _cached_size_.Get(); }
1030
1031 private:
1032 inline void SharedCtor();
1033 inline void SharedDtor();
1034 void SetCachedSize(int size) const final;
1035 void InternalSwap(RegisterTaskRequest* other);
1036 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1037 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1038 return "tensorflow.RegisterTaskRequest";
1039 }
1040 private:
1041 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1042 return nullptr;
1043 }
1044 inline void* MaybeArenaPtr() const {
1045 return nullptr;
1046 }
1047 public:
1048
1049 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1050 private:
1051 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1052 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1053 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1054 }
1055
1056 public:
1057
1058 // nested types ----------------------------------------------------
1059
1060 // accessors -------------------------------------------------------
1061
1062 enum : int {
1063 kSourceTaskFieldNumber = 5,
1064 kIncarnationFieldNumber = 3,
1065 };
1066 // .tensorflow.CoordinatedTask source_task = 5;
1067 bool has_source_task() const;
1068 void clear_source_task();
1069 const ::tensorflow::CoordinatedTask& source_task() const;
1070 ::tensorflow::CoordinatedTask* release_source_task();
1071 ::tensorflow::CoordinatedTask* mutable_source_task();
1072 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
1073
1074 // fixed64 incarnation = 3;
1075 void clear_incarnation();
1076 ::PROTOBUF_NAMESPACE_ID::uint64 incarnation() const;
1077 void set_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value);
1078
1079 // @@protoc_insertion_point(class_scope:tensorflow.RegisterTaskRequest)
1080 private:
1081 class _Internal;
1082
1083 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1084 ::tensorflow::CoordinatedTask* source_task_;
1085 ::PROTOBUF_NAMESPACE_ID::uint64 incarnation_;
1086 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1087 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1088};
1089// -------------------------------------------------------------------
1090
1091class RegisterTaskResponse :
1092 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.RegisterTaskResponse) */ {
1093 public:
1094 RegisterTaskResponse();
1095 virtual ~RegisterTaskResponse();
1096
1097 RegisterTaskResponse(const RegisterTaskResponse& from);
1098 RegisterTaskResponse(RegisterTaskResponse&& from) noexcept
1099 : RegisterTaskResponse() {
1100 *this = ::std::move(from);
1101 }
1102
1103 inline RegisterTaskResponse& operator=(const RegisterTaskResponse& from) {
1104 CopyFrom(from);
1105 return *this;
1106 }
1107 inline RegisterTaskResponse& operator=(RegisterTaskResponse&& from) noexcept {
1108 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1109 if (this != &from) InternalSwap(&from);
1110 } else {
1111 CopyFrom(from);
1112 }
1113 return *this;
1114 }
1115
1116 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1117 return GetDescriptor();
1118 }
1119 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1120 return GetMetadataStatic().descriptor;
1121 }
1122 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1123 return GetMetadataStatic().reflection;
1124 }
1125 static const RegisterTaskResponse& default_instance();
1126
1127 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1128 static inline const RegisterTaskResponse* internal_default_instance() {
1129 return reinterpret_cast<const RegisterTaskResponse*>(
1130 &_RegisterTaskResponse_default_instance_);
1131 }
1132 static constexpr int kIndexInFileMessages =
1133 6;
1134
1135 friend void swap(RegisterTaskResponse& a, RegisterTaskResponse& b) {
1136 a.Swap(&b);
1137 }
1138 inline void Swap(RegisterTaskResponse* other) {
1139 if (other == this) return;
1140 InternalSwap(other);
1141 }
1142
1143 // implements Message ----------------------------------------------
1144
1145 inline RegisterTaskResponse* New() const final {
1146 return CreateMaybeMessage<RegisterTaskResponse>(nullptr);
1147 }
1148
1149 RegisterTaskResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1150 return CreateMaybeMessage<RegisterTaskResponse>(arena);
1151 }
1152 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1153 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1154 void CopyFrom(const RegisterTaskResponse& from);
1155 void MergeFrom(const RegisterTaskResponse& from);
1156 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1157 bool IsInitialized() const final;
1158
1159 size_t ByteSizeLong() const final;
1160 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1161 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1162 #else
1163 bool MergePartialFromCodedStream(
1164 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1165 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1166 void SerializeWithCachedSizes(
1167 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1168 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1169 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1170 int GetCachedSize() const final { return _cached_size_.Get(); }
1171
1172 private:
1173 inline void SharedCtor();
1174 inline void SharedDtor();
1175 void SetCachedSize(int size) const final;
1176 void InternalSwap(RegisterTaskResponse* other);
1177 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1178 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1179 return "tensorflow.RegisterTaskResponse";
1180 }
1181 private:
1182 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1183 return nullptr;
1184 }
1185 inline void* MaybeArenaPtr() const {
1186 return nullptr;
1187 }
1188 public:
1189
1190 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1191 private:
1192 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1193 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1194 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1195 }
1196
1197 public:
1198
1199 // nested types ----------------------------------------------------
1200
1201 // accessors -------------------------------------------------------
1202
1203 enum : int {
1204 kLeaderIncarnationFieldNumber = 1,
1205 };
1206 // fixed64 leader_incarnation = 1;
1207 void clear_leader_incarnation();
1208 ::PROTOBUF_NAMESPACE_ID::uint64 leader_incarnation() const;
1209 void set_leader_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value);
1210
1211 // @@protoc_insertion_point(class_scope:tensorflow.RegisterTaskResponse)
1212 private:
1213 class _Internal;
1214
1215 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1216 ::PROTOBUF_NAMESPACE_ID::uint64 leader_incarnation_;
1217 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1218 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1219};
1220// -------------------------------------------------------------------
1221
1222class HeartbeatRequest :
1223 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.HeartbeatRequest) */ {
1224 public:
1225 HeartbeatRequest();
1226 virtual ~HeartbeatRequest();
1227
1228 HeartbeatRequest(const HeartbeatRequest& from);
1229 HeartbeatRequest(HeartbeatRequest&& from) noexcept
1230 : HeartbeatRequest() {
1231 *this = ::std::move(from);
1232 }
1233
1234 inline HeartbeatRequest& operator=(const HeartbeatRequest& from) {
1235 CopyFrom(from);
1236 return *this;
1237 }
1238 inline HeartbeatRequest& operator=(HeartbeatRequest&& from) noexcept {
1239 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1240 if (this != &from) InternalSwap(&from);
1241 } else {
1242 CopyFrom(from);
1243 }
1244 return *this;
1245 }
1246
1247 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1248 return GetDescriptor();
1249 }
1250 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1251 return GetMetadataStatic().descriptor;
1252 }
1253 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1254 return GetMetadataStatic().reflection;
1255 }
1256 static const HeartbeatRequest& default_instance();
1257
1258 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1259 static inline const HeartbeatRequest* internal_default_instance() {
1260 return reinterpret_cast<const HeartbeatRequest*>(
1261 &_HeartbeatRequest_default_instance_);
1262 }
1263 static constexpr int kIndexInFileMessages =
1264 7;
1265
1266 friend void swap(HeartbeatRequest& a, HeartbeatRequest& b) {
1267 a.Swap(&b);
1268 }
1269 inline void Swap(HeartbeatRequest* other) {
1270 if (other == this) return;
1271 InternalSwap(other);
1272 }
1273
1274 // implements Message ----------------------------------------------
1275
1276 inline HeartbeatRequest* New() const final {
1277 return CreateMaybeMessage<HeartbeatRequest>(nullptr);
1278 }
1279
1280 HeartbeatRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1281 return CreateMaybeMessage<HeartbeatRequest>(arena);
1282 }
1283 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1284 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1285 void CopyFrom(const HeartbeatRequest& from);
1286 void MergeFrom(const HeartbeatRequest& from);
1287 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1288 bool IsInitialized() const final;
1289
1290 size_t ByteSizeLong() const final;
1291 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1292 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1293 #else
1294 bool MergePartialFromCodedStream(
1295 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1296 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1297 void SerializeWithCachedSizes(
1298 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1299 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1300 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1301 int GetCachedSize() const final { return _cached_size_.Get(); }
1302
1303 private:
1304 inline void SharedCtor();
1305 inline void SharedDtor();
1306 void SetCachedSize(int size) const final;
1307 void InternalSwap(HeartbeatRequest* other);
1308 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1309 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1310 return "tensorflow.HeartbeatRequest";
1311 }
1312 private:
1313 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1314 return nullptr;
1315 }
1316 inline void* MaybeArenaPtr() const {
1317 return nullptr;
1318 }
1319 public:
1320
1321 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1322 private:
1323 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1324 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1325 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1326 }
1327
1328 public:
1329
1330 // nested types ----------------------------------------------------
1331
1332 // accessors -------------------------------------------------------
1333
1334 enum : int {
1335 kSourceTaskFieldNumber = 4,
1336 kIncarnationFieldNumber = 3,
1337 };
1338 // .tensorflow.CoordinatedTask source_task = 4;
1339 bool has_source_task() const;
1340 void clear_source_task();
1341 const ::tensorflow::CoordinatedTask& source_task() const;
1342 ::tensorflow::CoordinatedTask* release_source_task();
1343 ::tensorflow::CoordinatedTask* mutable_source_task();
1344 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
1345
1346 // fixed64 incarnation = 3;
1347 void clear_incarnation();
1348 ::PROTOBUF_NAMESPACE_ID::uint64 incarnation() const;
1349 void set_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value);
1350
1351 // @@protoc_insertion_point(class_scope:tensorflow.HeartbeatRequest)
1352 private:
1353 class _Internal;
1354
1355 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1356 ::tensorflow::CoordinatedTask* source_task_;
1357 ::PROTOBUF_NAMESPACE_ID::uint64 incarnation_;
1358 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1359 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1360};
1361// -------------------------------------------------------------------
1362
1363class HeartbeatResponse :
1364 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.HeartbeatResponse) */ {
1365 public:
1366 HeartbeatResponse();
1367 virtual ~HeartbeatResponse();
1368
1369 HeartbeatResponse(const HeartbeatResponse& from);
1370 HeartbeatResponse(HeartbeatResponse&& from) noexcept
1371 : HeartbeatResponse() {
1372 *this = ::std::move(from);
1373 }
1374
1375 inline HeartbeatResponse& operator=(const HeartbeatResponse& from) {
1376 CopyFrom(from);
1377 return *this;
1378 }
1379 inline HeartbeatResponse& operator=(HeartbeatResponse&& from) noexcept {
1380 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1381 if (this != &from) InternalSwap(&from);
1382 } else {
1383 CopyFrom(from);
1384 }
1385 return *this;
1386 }
1387
1388 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1389 return GetDescriptor();
1390 }
1391 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1392 return GetMetadataStatic().descriptor;
1393 }
1394 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1395 return GetMetadataStatic().reflection;
1396 }
1397 static const HeartbeatResponse& default_instance();
1398
1399 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1400 static inline const HeartbeatResponse* internal_default_instance() {
1401 return reinterpret_cast<const HeartbeatResponse*>(
1402 &_HeartbeatResponse_default_instance_);
1403 }
1404 static constexpr int kIndexInFileMessages =
1405 8;
1406
1407 friend void swap(HeartbeatResponse& a, HeartbeatResponse& b) {
1408 a.Swap(&b);
1409 }
1410 inline void Swap(HeartbeatResponse* other) {
1411 if (other == this) return;
1412 InternalSwap(other);
1413 }
1414
1415 // implements Message ----------------------------------------------
1416
1417 inline HeartbeatResponse* New() const final {
1418 return CreateMaybeMessage<HeartbeatResponse>(nullptr);
1419 }
1420
1421 HeartbeatResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1422 return CreateMaybeMessage<HeartbeatResponse>(arena);
1423 }
1424 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1425 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1426 void CopyFrom(const HeartbeatResponse& from);
1427 void MergeFrom(const HeartbeatResponse& from);
1428 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1429 bool IsInitialized() const final;
1430
1431 size_t ByteSizeLong() const final;
1432 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1433 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1434 #else
1435 bool MergePartialFromCodedStream(
1436 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1437 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1438 void SerializeWithCachedSizes(
1439 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1440 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1441 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1442 int GetCachedSize() const final { return _cached_size_.Get(); }
1443
1444 private:
1445 inline void SharedCtor();
1446 inline void SharedDtor();
1447 void SetCachedSize(int size) const final;
1448 void InternalSwap(HeartbeatResponse* other);
1449 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1450 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1451 return "tensorflow.HeartbeatResponse";
1452 }
1453 private:
1454 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1455 return nullptr;
1456 }
1457 inline void* MaybeArenaPtr() const {
1458 return nullptr;
1459 }
1460 public:
1461
1462 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1463 private:
1464 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1465 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1466 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1467 }
1468
1469 public:
1470
1471 // nested types ----------------------------------------------------
1472
1473 // accessors -------------------------------------------------------
1474
1475 enum : int {
1476 kLeaderIncarnationFieldNumber = 1,
1477 };
1478 // fixed64 leader_incarnation = 1;
1479 void clear_leader_incarnation();
1480 ::PROTOBUF_NAMESPACE_ID::uint64 leader_incarnation() const;
1481 void set_leader_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value);
1482
1483 // @@protoc_insertion_point(class_scope:tensorflow.HeartbeatResponse)
1484 private:
1485 class _Internal;
1486
1487 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1488 ::PROTOBUF_NAMESPACE_ID::uint64 leader_incarnation_;
1489 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1490 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1491};
1492// -------------------------------------------------------------------
1493
1494class WaitForAllTasksRequest :
1495 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.WaitForAllTasksRequest) */ {
1496 public:
1497 WaitForAllTasksRequest();
1498 virtual ~WaitForAllTasksRequest();
1499
1500 WaitForAllTasksRequest(const WaitForAllTasksRequest& from);
1501 WaitForAllTasksRequest(WaitForAllTasksRequest&& from) noexcept
1502 : WaitForAllTasksRequest() {
1503 *this = ::std::move(from);
1504 }
1505
1506 inline WaitForAllTasksRequest& operator=(const WaitForAllTasksRequest& from) {
1507 CopyFrom(from);
1508 return *this;
1509 }
1510 inline WaitForAllTasksRequest& operator=(WaitForAllTasksRequest&& from) noexcept {
1511 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1512 if (this != &from) InternalSwap(&from);
1513 } else {
1514 CopyFrom(from);
1515 }
1516 return *this;
1517 }
1518
1519 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1520 return GetDescriptor();
1521 }
1522 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1523 return GetMetadataStatic().descriptor;
1524 }
1525 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1526 return GetMetadataStatic().reflection;
1527 }
1528 static const WaitForAllTasksRequest& default_instance();
1529
1530 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1531 static inline const WaitForAllTasksRequest* internal_default_instance() {
1532 return reinterpret_cast<const WaitForAllTasksRequest*>(
1533 &_WaitForAllTasksRequest_default_instance_);
1534 }
1535 static constexpr int kIndexInFileMessages =
1536 9;
1537
1538 friend void swap(WaitForAllTasksRequest& a, WaitForAllTasksRequest& b) {
1539 a.Swap(&b);
1540 }
1541 inline void Swap(WaitForAllTasksRequest* other) {
1542 if (other == this) return;
1543 InternalSwap(other);
1544 }
1545
1546 // implements Message ----------------------------------------------
1547
1548 inline WaitForAllTasksRequest* New() const final {
1549 return CreateMaybeMessage<WaitForAllTasksRequest>(nullptr);
1550 }
1551
1552 WaitForAllTasksRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1553 return CreateMaybeMessage<WaitForAllTasksRequest>(arena);
1554 }
1555 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1556 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1557 void CopyFrom(const WaitForAllTasksRequest& from);
1558 void MergeFrom(const WaitForAllTasksRequest& from);
1559 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1560 bool IsInitialized() const final;
1561
1562 size_t ByteSizeLong() const final;
1563 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1564 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1565 #else
1566 bool MergePartialFromCodedStream(
1567 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1568 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1569 void SerializeWithCachedSizes(
1570 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1571 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1572 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1573 int GetCachedSize() const final { return _cached_size_.Get(); }
1574
1575 private:
1576 inline void SharedCtor();
1577 inline void SharedDtor();
1578 void SetCachedSize(int size) const final;
1579 void InternalSwap(WaitForAllTasksRequest* other);
1580 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1581 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1582 return "tensorflow.WaitForAllTasksRequest";
1583 }
1584 private:
1585 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1586 return nullptr;
1587 }
1588 inline void* MaybeArenaPtr() const {
1589 return nullptr;
1590 }
1591 public:
1592
1593 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1594 private:
1595 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1596 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1597 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1598 }
1599
1600 public:
1601
1602 // nested types ----------------------------------------------------
1603
1604 // accessors -------------------------------------------------------
1605
1606 enum : int {
1607 kLocalDeviceInfoFieldNumber = 4,
1608 kSourceTaskFieldNumber = 5,
1609 };
1610 // .tensorflow.CoordinationServiceDeviceInfo local_device_info = 4;
1611 bool has_local_device_info() const;
1612 void clear_local_device_info();
1613 const ::tensorflow::CoordinationServiceDeviceInfo& local_device_info() const;
1614 ::tensorflow::CoordinationServiceDeviceInfo* release_local_device_info();
1615 ::tensorflow::CoordinationServiceDeviceInfo* mutable_local_device_info();
1616 void set_allocated_local_device_info(::tensorflow::CoordinationServiceDeviceInfo* local_device_info);
1617
1618 // .tensorflow.CoordinatedTask source_task = 5;
1619 bool has_source_task() const;
1620 void clear_source_task();
1621 const ::tensorflow::CoordinatedTask& source_task() const;
1622 ::tensorflow::CoordinatedTask* release_source_task();
1623 ::tensorflow::CoordinatedTask* mutable_source_task();
1624 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
1625
1626 // @@protoc_insertion_point(class_scope:tensorflow.WaitForAllTasksRequest)
1627 private:
1628 class _Internal;
1629
1630 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1631 ::tensorflow::CoordinationServiceDeviceInfo* local_device_info_;
1632 ::tensorflow::CoordinatedTask* source_task_;
1633 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1634 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1635};
1636// -------------------------------------------------------------------
1637
1638class WaitForAllTasksResponse :
1639 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.WaitForAllTasksResponse) */ {
1640 public:
1641 WaitForAllTasksResponse();
1642 virtual ~WaitForAllTasksResponse();
1643
1644 WaitForAllTasksResponse(const WaitForAllTasksResponse& from);
1645 WaitForAllTasksResponse(WaitForAllTasksResponse&& from) noexcept
1646 : WaitForAllTasksResponse() {
1647 *this = ::std::move(from);
1648 }
1649
1650 inline WaitForAllTasksResponse& operator=(const WaitForAllTasksResponse& from) {
1651 CopyFrom(from);
1652 return *this;
1653 }
1654 inline WaitForAllTasksResponse& operator=(WaitForAllTasksResponse&& from) noexcept {
1655 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1656 if (this != &from) InternalSwap(&from);
1657 } else {
1658 CopyFrom(from);
1659 }
1660 return *this;
1661 }
1662
1663 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1664 return GetDescriptor();
1665 }
1666 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1667 return GetMetadataStatic().descriptor;
1668 }
1669 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1670 return GetMetadataStatic().reflection;
1671 }
1672 static const WaitForAllTasksResponse& default_instance();
1673
1674 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1675 static inline const WaitForAllTasksResponse* internal_default_instance() {
1676 return reinterpret_cast<const WaitForAllTasksResponse*>(
1677 &_WaitForAllTasksResponse_default_instance_);
1678 }
1679 static constexpr int kIndexInFileMessages =
1680 10;
1681
1682 friend void swap(WaitForAllTasksResponse& a, WaitForAllTasksResponse& b) {
1683 a.Swap(&b);
1684 }
1685 inline void Swap(WaitForAllTasksResponse* other) {
1686 if (other == this) return;
1687 InternalSwap(other);
1688 }
1689
1690 // implements Message ----------------------------------------------
1691
1692 inline WaitForAllTasksResponse* New() const final {
1693 return CreateMaybeMessage<WaitForAllTasksResponse>(nullptr);
1694 }
1695
1696 WaitForAllTasksResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1697 return CreateMaybeMessage<WaitForAllTasksResponse>(arena);
1698 }
1699 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1700 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1701 void CopyFrom(const WaitForAllTasksResponse& from);
1702 void MergeFrom(const WaitForAllTasksResponse& from);
1703 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1704 bool IsInitialized() const final;
1705
1706 size_t ByteSizeLong() const final;
1707 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1708 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1709 #else
1710 bool MergePartialFromCodedStream(
1711 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1712 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1713 void SerializeWithCachedSizes(
1714 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1715 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1716 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1717 int GetCachedSize() const final { return _cached_size_.Get(); }
1718
1719 private:
1720 inline void SharedCtor();
1721 inline void SharedDtor();
1722 void SetCachedSize(int size) const final;
1723 void InternalSwap(WaitForAllTasksResponse* other);
1724 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1725 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1726 return "tensorflow.WaitForAllTasksResponse";
1727 }
1728 private:
1729 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1730 return nullptr;
1731 }
1732 inline void* MaybeArenaPtr() const {
1733 return nullptr;
1734 }
1735 public:
1736
1737 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1738 private:
1739 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1740 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1741 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1742 }
1743
1744 public:
1745
1746 // nested types ----------------------------------------------------
1747
1748 // accessors -------------------------------------------------------
1749
1750 enum : int {
1751 kClusterDeviceInfoFieldNumber = 3,
1752 kLeaderIncarnationFieldNumber = 1,
1753 };
1754 // .tensorflow.CoordinationServiceDeviceInfo cluster_device_info = 3;
1755 bool has_cluster_device_info() const;
1756 void clear_cluster_device_info();
1757 const ::tensorflow::CoordinationServiceDeviceInfo& cluster_device_info() const;
1758 ::tensorflow::CoordinationServiceDeviceInfo* release_cluster_device_info();
1759 ::tensorflow::CoordinationServiceDeviceInfo* mutable_cluster_device_info();
1760 void set_allocated_cluster_device_info(::tensorflow::CoordinationServiceDeviceInfo* cluster_device_info);
1761
1762 // fixed64 leader_incarnation = 1;
1763 void clear_leader_incarnation();
1764 ::PROTOBUF_NAMESPACE_ID::uint64 leader_incarnation() const;
1765 void set_leader_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value);
1766
1767 // @@protoc_insertion_point(class_scope:tensorflow.WaitForAllTasksResponse)
1768 private:
1769 class _Internal;
1770
1771 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1772 ::tensorflow::CoordinationServiceDeviceInfo* cluster_device_info_;
1773 ::PROTOBUF_NAMESPACE_ID::uint64 leader_incarnation_;
1774 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1775 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1776};
1777// -------------------------------------------------------------------
1778
1779class ShutdownTaskRequest :
1780 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ShutdownTaskRequest) */ {
1781 public:
1782 ShutdownTaskRequest();
1783 virtual ~ShutdownTaskRequest();
1784
1785 ShutdownTaskRequest(const ShutdownTaskRequest& from);
1786 ShutdownTaskRequest(ShutdownTaskRequest&& from) noexcept
1787 : ShutdownTaskRequest() {
1788 *this = ::std::move(from);
1789 }
1790
1791 inline ShutdownTaskRequest& operator=(const ShutdownTaskRequest& from) {
1792 CopyFrom(from);
1793 return *this;
1794 }
1795 inline ShutdownTaskRequest& operator=(ShutdownTaskRequest&& from) noexcept {
1796 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1797 if (this != &from) InternalSwap(&from);
1798 } else {
1799 CopyFrom(from);
1800 }
1801 return *this;
1802 }
1803
1804 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1805 return GetDescriptor();
1806 }
1807 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1808 return GetMetadataStatic().descriptor;
1809 }
1810 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1811 return GetMetadataStatic().reflection;
1812 }
1813 static const ShutdownTaskRequest& default_instance();
1814
1815 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1816 static inline const ShutdownTaskRequest* internal_default_instance() {
1817 return reinterpret_cast<const ShutdownTaskRequest*>(
1818 &_ShutdownTaskRequest_default_instance_);
1819 }
1820 static constexpr int kIndexInFileMessages =
1821 11;
1822
1823 friend void swap(ShutdownTaskRequest& a, ShutdownTaskRequest& b) {
1824 a.Swap(&b);
1825 }
1826 inline void Swap(ShutdownTaskRequest* other) {
1827 if (other == this) return;
1828 InternalSwap(other);
1829 }
1830
1831 // implements Message ----------------------------------------------
1832
1833 inline ShutdownTaskRequest* New() const final {
1834 return CreateMaybeMessage<ShutdownTaskRequest>(nullptr);
1835 }
1836
1837 ShutdownTaskRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1838 return CreateMaybeMessage<ShutdownTaskRequest>(arena);
1839 }
1840 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1841 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1842 void CopyFrom(const ShutdownTaskRequest& from);
1843 void MergeFrom(const ShutdownTaskRequest& from);
1844 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1845 bool IsInitialized() const final;
1846
1847 size_t ByteSizeLong() const final;
1848 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1849 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1850 #else
1851 bool MergePartialFromCodedStream(
1852 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1853 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1854 void SerializeWithCachedSizes(
1855 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1856 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1857 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1858 int GetCachedSize() const final { return _cached_size_.Get(); }
1859
1860 private:
1861 inline void SharedCtor();
1862 inline void SharedDtor();
1863 void SetCachedSize(int size) const final;
1864 void InternalSwap(ShutdownTaskRequest* other);
1865 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1866 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1867 return "tensorflow.ShutdownTaskRequest";
1868 }
1869 private:
1870 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1871 return nullptr;
1872 }
1873 inline void* MaybeArenaPtr() const {
1874 return nullptr;
1875 }
1876 public:
1877
1878 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1879 private:
1880 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1881 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
1882 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
1883 }
1884
1885 public:
1886
1887 // nested types ----------------------------------------------------
1888
1889 // accessors -------------------------------------------------------
1890
1891 enum : int {
1892 kSourceTaskFieldNumber = 1,
1893 };
1894 // .tensorflow.CoordinatedTask source_task = 1;
1895 bool has_source_task() const;
1896 void clear_source_task();
1897 const ::tensorflow::CoordinatedTask& source_task() const;
1898 ::tensorflow::CoordinatedTask* release_source_task();
1899 ::tensorflow::CoordinatedTask* mutable_source_task();
1900 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
1901
1902 // @@protoc_insertion_point(class_scope:tensorflow.ShutdownTaskRequest)
1903 private:
1904 class _Internal;
1905
1906 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1907 ::tensorflow::CoordinatedTask* source_task_;
1908 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1909 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
1910};
1911// -------------------------------------------------------------------
1912
1913class ShutdownTaskResponse :
1914 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ShutdownTaskResponse) */ {
1915 public:
1916 ShutdownTaskResponse();
1917 virtual ~ShutdownTaskResponse();
1918
1919 ShutdownTaskResponse(const ShutdownTaskResponse& from);
1920 ShutdownTaskResponse(ShutdownTaskResponse&& from) noexcept
1921 : ShutdownTaskResponse() {
1922 *this = ::std::move(from);
1923 }
1924
1925 inline ShutdownTaskResponse& operator=(const ShutdownTaskResponse& from) {
1926 CopyFrom(from);
1927 return *this;
1928 }
1929 inline ShutdownTaskResponse& operator=(ShutdownTaskResponse&& from) noexcept {
1930 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1931 if (this != &from) InternalSwap(&from);
1932 } else {
1933 CopyFrom(from);
1934 }
1935 return *this;
1936 }
1937
1938 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1939 return GetDescriptor();
1940 }
1941 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1942 return GetMetadataStatic().descriptor;
1943 }
1944 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1945 return GetMetadataStatic().reflection;
1946 }
1947 static const ShutdownTaskResponse& default_instance();
1948
1949 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1950 static inline const ShutdownTaskResponse* internal_default_instance() {
1951 return reinterpret_cast<const ShutdownTaskResponse*>(
1952 &_ShutdownTaskResponse_default_instance_);
1953 }
1954 static constexpr int kIndexInFileMessages =
1955 12;
1956
1957 friend void swap(ShutdownTaskResponse& a, ShutdownTaskResponse& b) {
1958 a.Swap(&b);
1959 }
1960 inline void Swap(ShutdownTaskResponse* other) {
1961 if (other == this) return;
1962 InternalSwap(other);
1963 }
1964
1965 // implements Message ----------------------------------------------
1966
1967 inline ShutdownTaskResponse* New() const final {
1968 return CreateMaybeMessage<ShutdownTaskResponse>(nullptr);
1969 }
1970
1971 ShutdownTaskResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1972 return CreateMaybeMessage<ShutdownTaskResponse>(arena);
1973 }
1974 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1975 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1976 void CopyFrom(const ShutdownTaskResponse& from);
1977 void MergeFrom(const ShutdownTaskResponse& from);
1978 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1979 bool IsInitialized() const final;
1980
1981 size_t ByteSizeLong() const final;
1982 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1983 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1984 #else
1985 bool MergePartialFromCodedStream(
1986 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1987 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1988 void SerializeWithCachedSizes(
1989 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1990 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1991 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1992 int GetCachedSize() const final { return _cached_size_.Get(); }
1993
1994 private:
1995 inline void SharedCtor();
1996 inline void SharedDtor();
1997 void SetCachedSize(int size) const final;
1998 void InternalSwap(ShutdownTaskResponse* other);
1999 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2000 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2001 return "tensorflow.ShutdownTaskResponse";
2002 }
2003 private:
2004 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2005 return nullptr;
2006 }
2007 inline void* MaybeArenaPtr() const {
2008 return nullptr;
2009 }
2010 public:
2011
2012 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2013 private:
2014 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2015 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2016 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2017 }
2018
2019 public:
2020
2021 // nested types ----------------------------------------------------
2022
2023 // accessors -------------------------------------------------------
2024
2025 // @@protoc_insertion_point(class_scope:tensorflow.ShutdownTaskResponse)
2026 private:
2027 class _Internal;
2028
2029 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2030 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2031 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2032};
2033// -------------------------------------------------------------------
2034
2035class ResetTaskRequest :
2036 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ResetTaskRequest) */ {
2037 public:
2038 ResetTaskRequest();
2039 virtual ~ResetTaskRequest();
2040
2041 ResetTaskRequest(const ResetTaskRequest& from);
2042 ResetTaskRequest(ResetTaskRequest&& from) noexcept
2043 : ResetTaskRequest() {
2044 *this = ::std::move(from);
2045 }
2046
2047 inline ResetTaskRequest& operator=(const ResetTaskRequest& from) {
2048 CopyFrom(from);
2049 return *this;
2050 }
2051 inline ResetTaskRequest& operator=(ResetTaskRequest&& from) noexcept {
2052 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2053 if (this != &from) InternalSwap(&from);
2054 } else {
2055 CopyFrom(from);
2056 }
2057 return *this;
2058 }
2059
2060 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2061 return GetDescriptor();
2062 }
2063 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2064 return GetMetadataStatic().descriptor;
2065 }
2066 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2067 return GetMetadataStatic().reflection;
2068 }
2069 static const ResetTaskRequest& default_instance();
2070
2071 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2072 static inline const ResetTaskRequest* internal_default_instance() {
2073 return reinterpret_cast<const ResetTaskRequest*>(
2074 &_ResetTaskRequest_default_instance_);
2075 }
2076 static constexpr int kIndexInFileMessages =
2077 13;
2078
2079 friend void swap(ResetTaskRequest& a, ResetTaskRequest& b) {
2080 a.Swap(&b);
2081 }
2082 inline void Swap(ResetTaskRequest* other) {
2083 if (other == this) return;
2084 InternalSwap(other);
2085 }
2086
2087 // implements Message ----------------------------------------------
2088
2089 inline ResetTaskRequest* New() const final {
2090 return CreateMaybeMessage<ResetTaskRequest>(nullptr);
2091 }
2092
2093 ResetTaskRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2094 return CreateMaybeMessage<ResetTaskRequest>(arena);
2095 }
2096 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2097 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2098 void CopyFrom(const ResetTaskRequest& from);
2099 void MergeFrom(const ResetTaskRequest& from);
2100 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2101 bool IsInitialized() const final;
2102
2103 size_t ByteSizeLong() const final;
2104 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2105 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2106 #else
2107 bool MergePartialFromCodedStream(
2108 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2109 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2110 void SerializeWithCachedSizes(
2111 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2112 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2113 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2114 int GetCachedSize() const final { return _cached_size_.Get(); }
2115
2116 private:
2117 inline void SharedCtor();
2118 inline void SharedDtor();
2119 void SetCachedSize(int size) const final;
2120 void InternalSwap(ResetTaskRequest* other);
2121 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2122 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2123 return "tensorflow.ResetTaskRequest";
2124 }
2125 private:
2126 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2127 return nullptr;
2128 }
2129 inline void* MaybeArenaPtr() const {
2130 return nullptr;
2131 }
2132 public:
2133
2134 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2135 private:
2136 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2137 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2138 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2139 }
2140
2141 public:
2142
2143 // nested types ----------------------------------------------------
2144
2145 // accessors -------------------------------------------------------
2146
2147 enum : int {
2148 kSourceTaskFieldNumber = 1,
2149 };
2150 // .tensorflow.CoordinatedTask source_task = 1;
2151 bool has_source_task() const;
2152 void clear_source_task();
2153 const ::tensorflow::CoordinatedTask& source_task() const;
2154 ::tensorflow::CoordinatedTask* release_source_task();
2155 ::tensorflow::CoordinatedTask* mutable_source_task();
2156 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
2157
2158 // @@protoc_insertion_point(class_scope:tensorflow.ResetTaskRequest)
2159 private:
2160 class _Internal;
2161
2162 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2163 ::tensorflow::CoordinatedTask* source_task_;
2164 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2165 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2166};
2167// -------------------------------------------------------------------
2168
2169class ResetTaskResponse :
2170 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ResetTaskResponse) */ {
2171 public:
2172 ResetTaskResponse();
2173 virtual ~ResetTaskResponse();
2174
2175 ResetTaskResponse(const ResetTaskResponse& from);
2176 ResetTaskResponse(ResetTaskResponse&& from) noexcept
2177 : ResetTaskResponse() {
2178 *this = ::std::move(from);
2179 }
2180
2181 inline ResetTaskResponse& operator=(const ResetTaskResponse& from) {
2182 CopyFrom(from);
2183 return *this;
2184 }
2185 inline ResetTaskResponse& operator=(ResetTaskResponse&& from) noexcept {
2186 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2187 if (this != &from) InternalSwap(&from);
2188 } else {
2189 CopyFrom(from);
2190 }
2191 return *this;
2192 }
2193
2194 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2195 return GetDescriptor();
2196 }
2197 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2198 return GetMetadataStatic().descriptor;
2199 }
2200 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2201 return GetMetadataStatic().reflection;
2202 }
2203 static const ResetTaskResponse& default_instance();
2204
2205 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2206 static inline const ResetTaskResponse* internal_default_instance() {
2207 return reinterpret_cast<const ResetTaskResponse*>(
2208 &_ResetTaskResponse_default_instance_);
2209 }
2210 static constexpr int kIndexInFileMessages =
2211 14;
2212
2213 friend void swap(ResetTaskResponse& a, ResetTaskResponse& b) {
2214 a.Swap(&b);
2215 }
2216 inline void Swap(ResetTaskResponse* other) {
2217 if (other == this) return;
2218 InternalSwap(other);
2219 }
2220
2221 // implements Message ----------------------------------------------
2222
2223 inline ResetTaskResponse* New() const final {
2224 return CreateMaybeMessage<ResetTaskResponse>(nullptr);
2225 }
2226
2227 ResetTaskResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2228 return CreateMaybeMessage<ResetTaskResponse>(arena);
2229 }
2230 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2231 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2232 void CopyFrom(const ResetTaskResponse& from);
2233 void MergeFrom(const ResetTaskResponse& from);
2234 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2235 bool IsInitialized() const final;
2236
2237 size_t ByteSizeLong() const final;
2238 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2239 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2240 #else
2241 bool MergePartialFromCodedStream(
2242 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2243 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2244 void SerializeWithCachedSizes(
2245 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2246 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2247 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2248 int GetCachedSize() const final { return _cached_size_.Get(); }
2249
2250 private:
2251 inline void SharedCtor();
2252 inline void SharedDtor();
2253 void SetCachedSize(int size) const final;
2254 void InternalSwap(ResetTaskResponse* other);
2255 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2256 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2257 return "tensorflow.ResetTaskResponse";
2258 }
2259 private:
2260 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2261 return nullptr;
2262 }
2263 inline void* MaybeArenaPtr() const {
2264 return nullptr;
2265 }
2266 public:
2267
2268 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2269 private:
2270 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2271 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2272 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2273 }
2274
2275 public:
2276
2277 // nested types ----------------------------------------------------
2278
2279 // accessors -------------------------------------------------------
2280
2281 // @@protoc_insertion_point(class_scope:tensorflow.ResetTaskResponse)
2282 private:
2283 class _Internal;
2284
2285 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2286 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2287 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2288};
2289// -------------------------------------------------------------------
2290
2291class ReportErrorToTaskRequest :
2292 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ReportErrorToTaskRequest) */ {
2293 public:
2294 ReportErrorToTaskRequest();
2295 virtual ~ReportErrorToTaskRequest();
2296
2297 ReportErrorToTaskRequest(const ReportErrorToTaskRequest& from);
2298 ReportErrorToTaskRequest(ReportErrorToTaskRequest&& from) noexcept
2299 : ReportErrorToTaskRequest() {
2300 *this = ::std::move(from);
2301 }
2302
2303 inline ReportErrorToTaskRequest& operator=(const ReportErrorToTaskRequest& from) {
2304 CopyFrom(from);
2305 return *this;
2306 }
2307 inline ReportErrorToTaskRequest& operator=(ReportErrorToTaskRequest&& from) noexcept {
2308 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2309 if (this != &from) InternalSwap(&from);
2310 } else {
2311 CopyFrom(from);
2312 }
2313 return *this;
2314 }
2315
2316 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2317 return GetDescriptor();
2318 }
2319 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2320 return GetMetadataStatic().descriptor;
2321 }
2322 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2323 return GetMetadataStatic().reflection;
2324 }
2325 static const ReportErrorToTaskRequest& default_instance();
2326
2327 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2328 static inline const ReportErrorToTaskRequest* internal_default_instance() {
2329 return reinterpret_cast<const ReportErrorToTaskRequest*>(
2330 &_ReportErrorToTaskRequest_default_instance_);
2331 }
2332 static constexpr int kIndexInFileMessages =
2333 15;
2334
2335 friend void swap(ReportErrorToTaskRequest& a, ReportErrorToTaskRequest& b) {
2336 a.Swap(&b);
2337 }
2338 inline void Swap(ReportErrorToTaskRequest* other) {
2339 if (other == this) return;
2340 InternalSwap(other);
2341 }
2342
2343 // implements Message ----------------------------------------------
2344
2345 inline ReportErrorToTaskRequest* New() const final {
2346 return CreateMaybeMessage<ReportErrorToTaskRequest>(nullptr);
2347 }
2348
2349 ReportErrorToTaskRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2350 return CreateMaybeMessage<ReportErrorToTaskRequest>(arena);
2351 }
2352 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2353 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2354 void CopyFrom(const ReportErrorToTaskRequest& from);
2355 void MergeFrom(const ReportErrorToTaskRequest& from);
2356 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2357 bool IsInitialized() const final;
2358
2359 size_t ByteSizeLong() const final;
2360 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2361 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2362 #else
2363 bool MergePartialFromCodedStream(
2364 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2365 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2366 void SerializeWithCachedSizes(
2367 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2368 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2369 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2370 int GetCachedSize() const final { return _cached_size_.Get(); }
2371
2372 private:
2373 inline void SharedCtor();
2374 inline void SharedDtor();
2375 void SetCachedSize(int size) const final;
2376 void InternalSwap(ReportErrorToTaskRequest* other);
2377 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2378 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2379 return "tensorflow.ReportErrorToTaskRequest";
2380 }
2381 private:
2382 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2383 return nullptr;
2384 }
2385 inline void* MaybeArenaPtr() const {
2386 return nullptr;
2387 }
2388 public:
2389
2390 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2391 private:
2392 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2393 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2394 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2395 }
2396
2397 public:
2398
2399 // nested types ----------------------------------------------------
2400
2401 // accessors -------------------------------------------------------
2402
2403 enum : int {
2404 kErrorMessageFieldNumber = 2,
2405 kErrorPayloadFieldNumber = 5,
2406 kErrorCodeFieldNumber = 1,
2407 };
2408 // string error_message = 2;
2409 void clear_error_message();
2410 const std::string& error_message() const;
2411 void set_error_message(const std::string& value);
2412 void set_error_message(std::string&& value);
2413 void set_error_message(const char* value);
2414 void set_error_message(const char* value, size_t size);
2415 std::string* mutable_error_message();
2416 std::string* release_error_message();
2417 void set_allocated_error_message(std::string* error_message);
2418
2419 // .tensorflow.CoordinationServiceError error_payload = 5;
2420 bool has_error_payload() const;
2421 void clear_error_payload();
2422 const ::tensorflow::CoordinationServiceError& error_payload() const;
2423 ::tensorflow::CoordinationServiceError* release_error_payload();
2424 ::tensorflow::CoordinationServiceError* mutable_error_payload();
2425 void set_allocated_error_payload(::tensorflow::CoordinationServiceError* error_payload);
2426
2427 // int32 error_code = 1;
2428 void clear_error_code();
2429 ::PROTOBUF_NAMESPACE_ID::int32 error_code() const;
2430 void set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value);
2431
2432 // @@protoc_insertion_point(class_scope:tensorflow.ReportErrorToTaskRequest)
2433 private:
2434 class _Internal;
2435
2436 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2437 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
2438 ::tensorflow::CoordinationServiceError* error_payload_;
2439 ::PROTOBUF_NAMESPACE_ID::int32 error_code_;
2440 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2441 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2442};
2443// -------------------------------------------------------------------
2444
2445class ReportErrorToTaskResponse :
2446 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ReportErrorToTaskResponse) */ {
2447 public:
2448 ReportErrorToTaskResponse();
2449 virtual ~ReportErrorToTaskResponse();
2450
2451 ReportErrorToTaskResponse(const ReportErrorToTaskResponse& from);
2452 ReportErrorToTaskResponse(ReportErrorToTaskResponse&& from) noexcept
2453 : ReportErrorToTaskResponse() {
2454 *this = ::std::move(from);
2455 }
2456
2457 inline ReportErrorToTaskResponse& operator=(const ReportErrorToTaskResponse& from) {
2458 CopyFrom(from);
2459 return *this;
2460 }
2461 inline ReportErrorToTaskResponse& operator=(ReportErrorToTaskResponse&& from) noexcept {
2462 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2463 if (this != &from) InternalSwap(&from);
2464 } else {
2465 CopyFrom(from);
2466 }
2467 return *this;
2468 }
2469
2470 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2471 return GetDescriptor();
2472 }
2473 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2474 return GetMetadataStatic().descriptor;
2475 }
2476 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2477 return GetMetadataStatic().reflection;
2478 }
2479 static const ReportErrorToTaskResponse& default_instance();
2480
2481 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2482 static inline const ReportErrorToTaskResponse* internal_default_instance() {
2483 return reinterpret_cast<const ReportErrorToTaskResponse*>(
2484 &_ReportErrorToTaskResponse_default_instance_);
2485 }
2486 static constexpr int kIndexInFileMessages =
2487 16;
2488
2489 friend void swap(ReportErrorToTaskResponse& a, ReportErrorToTaskResponse& b) {
2490 a.Swap(&b);
2491 }
2492 inline void Swap(ReportErrorToTaskResponse* other) {
2493 if (other == this) return;
2494 InternalSwap(other);
2495 }
2496
2497 // implements Message ----------------------------------------------
2498
2499 inline ReportErrorToTaskResponse* New() const final {
2500 return CreateMaybeMessage<ReportErrorToTaskResponse>(nullptr);
2501 }
2502
2503 ReportErrorToTaskResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2504 return CreateMaybeMessage<ReportErrorToTaskResponse>(arena);
2505 }
2506 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2507 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2508 void CopyFrom(const ReportErrorToTaskResponse& from);
2509 void MergeFrom(const ReportErrorToTaskResponse& from);
2510 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2511 bool IsInitialized() const final;
2512
2513 size_t ByteSizeLong() const final;
2514 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2515 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2516 #else
2517 bool MergePartialFromCodedStream(
2518 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2519 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2520 void SerializeWithCachedSizes(
2521 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2522 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2523 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2524 int GetCachedSize() const final { return _cached_size_.Get(); }
2525
2526 private:
2527 inline void SharedCtor();
2528 inline void SharedDtor();
2529 void SetCachedSize(int size) const final;
2530 void InternalSwap(ReportErrorToTaskResponse* other);
2531 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2532 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2533 return "tensorflow.ReportErrorToTaskResponse";
2534 }
2535 private:
2536 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2537 return nullptr;
2538 }
2539 inline void* MaybeArenaPtr() const {
2540 return nullptr;
2541 }
2542 public:
2543
2544 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2545 private:
2546 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2547 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2548 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2549 }
2550
2551 public:
2552
2553 // nested types ----------------------------------------------------
2554
2555 // accessors -------------------------------------------------------
2556
2557 // @@protoc_insertion_point(class_scope:tensorflow.ReportErrorToTaskResponse)
2558 private:
2559 class _Internal;
2560
2561 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2562 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2563 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2564};
2565// -------------------------------------------------------------------
2566
2567class ReportErrorToServiceRequest :
2568 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ReportErrorToServiceRequest) */ {
2569 public:
2570 ReportErrorToServiceRequest();
2571 virtual ~ReportErrorToServiceRequest();
2572
2573 ReportErrorToServiceRequest(const ReportErrorToServiceRequest& from);
2574 ReportErrorToServiceRequest(ReportErrorToServiceRequest&& from) noexcept
2575 : ReportErrorToServiceRequest() {
2576 *this = ::std::move(from);
2577 }
2578
2579 inline ReportErrorToServiceRequest& operator=(const ReportErrorToServiceRequest& from) {
2580 CopyFrom(from);
2581 return *this;
2582 }
2583 inline ReportErrorToServiceRequest& operator=(ReportErrorToServiceRequest&& from) noexcept {
2584 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2585 if (this != &from) InternalSwap(&from);
2586 } else {
2587 CopyFrom(from);
2588 }
2589 return *this;
2590 }
2591
2592 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2593 return GetDescriptor();
2594 }
2595 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2596 return GetMetadataStatic().descriptor;
2597 }
2598 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2599 return GetMetadataStatic().reflection;
2600 }
2601 static const ReportErrorToServiceRequest& default_instance();
2602
2603 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2604 static inline const ReportErrorToServiceRequest* internal_default_instance() {
2605 return reinterpret_cast<const ReportErrorToServiceRequest*>(
2606 &_ReportErrorToServiceRequest_default_instance_);
2607 }
2608 static constexpr int kIndexInFileMessages =
2609 17;
2610
2611 friend void swap(ReportErrorToServiceRequest& a, ReportErrorToServiceRequest& b) {
2612 a.Swap(&b);
2613 }
2614 inline void Swap(ReportErrorToServiceRequest* other) {
2615 if (other == this) return;
2616 InternalSwap(other);
2617 }
2618
2619 // implements Message ----------------------------------------------
2620
2621 inline ReportErrorToServiceRequest* New() const final {
2622 return CreateMaybeMessage<ReportErrorToServiceRequest>(nullptr);
2623 }
2624
2625 ReportErrorToServiceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2626 return CreateMaybeMessage<ReportErrorToServiceRequest>(arena);
2627 }
2628 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2629 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2630 void CopyFrom(const ReportErrorToServiceRequest& from);
2631 void MergeFrom(const ReportErrorToServiceRequest& from);
2632 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2633 bool IsInitialized() const final;
2634
2635 size_t ByteSizeLong() const final;
2636 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2637 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2638 #else
2639 bool MergePartialFromCodedStream(
2640 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2641 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2642 void SerializeWithCachedSizes(
2643 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2644 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2645 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2646 int GetCachedSize() const final { return _cached_size_.Get(); }
2647
2648 private:
2649 inline void SharedCtor();
2650 inline void SharedDtor();
2651 void SetCachedSize(int size) const final;
2652 void InternalSwap(ReportErrorToServiceRequest* other);
2653 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2654 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2655 return "tensorflow.ReportErrorToServiceRequest";
2656 }
2657 private:
2658 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2659 return nullptr;
2660 }
2661 inline void* MaybeArenaPtr() const {
2662 return nullptr;
2663 }
2664 public:
2665
2666 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2667 private:
2668 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2669 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2670 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2671 }
2672
2673 public:
2674
2675 // nested types ----------------------------------------------------
2676
2677 // accessors -------------------------------------------------------
2678
2679 enum : int {
2680 kErrorMessageFieldNumber = 2,
2681 kErrorOriginFieldNumber = 5,
2682 kErrorCodeFieldNumber = 1,
2683 };
2684 // string error_message = 2;
2685 void clear_error_message();
2686 const std::string& error_message() const;
2687 void set_error_message(const std::string& value);
2688 void set_error_message(std::string&& value);
2689 void set_error_message(const char* value);
2690 void set_error_message(const char* value, size_t size);
2691 std::string* mutable_error_message();
2692 std::string* release_error_message();
2693 void set_allocated_error_message(std::string* error_message);
2694
2695 // .tensorflow.CoordinatedTask error_origin = 5;
2696 bool has_error_origin() const;
2697 void clear_error_origin();
2698 const ::tensorflow::CoordinatedTask& error_origin() const;
2699 ::tensorflow::CoordinatedTask* release_error_origin();
2700 ::tensorflow::CoordinatedTask* mutable_error_origin();
2701 void set_allocated_error_origin(::tensorflow::CoordinatedTask* error_origin);
2702
2703 // int32 error_code = 1;
2704 void clear_error_code();
2705 ::PROTOBUF_NAMESPACE_ID::int32 error_code() const;
2706 void set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value);
2707
2708 // @@protoc_insertion_point(class_scope:tensorflow.ReportErrorToServiceRequest)
2709 private:
2710 class _Internal;
2711
2712 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2713 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr error_message_;
2714 ::tensorflow::CoordinatedTask* error_origin_;
2715 ::PROTOBUF_NAMESPACE_ID::int32 error_code_;
2716 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2717 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2718};
2719// -------------------------------------------------------------------
2720
2721class ReportErrorToServiceResponse :
2722 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ReportErrorToServiceResponse) */ {
2723 public:
2724 ReportErrorToServiceResponse();
2725 virtual ~ReportErrorToServiceResponse();
2726
2727 ReportErrorToServiceResponse(const ReportErrorToServiceResponse& from);
2728 ReportErrorToServiceResponse(ReportErrorToServiceResponse&& from) noexcept
2729 : ReportErrorToServiceResponse() {
2730 *this = ::std::move(from);
2731 }
2732
2733 inline ReportErrorToServiceResponse& operator=(const ReportErrorToServiceResponse& from) {
2734 CopyFrom(from);
2735 return *this;
2736 }
2737 inline ReportErrorToServiceResponse& operator=(ReportErrorToServiceResponse&& from) noexcept {
2738 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2739 if (this != &from) InternalSwap(&from);
2740 } else {
2741 CopyFrom(from);
2742 }
2743 return *this;
2744 }
2745
2746 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2747 return GetDescriptor();
2748 }
2749 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2750 return GetMetadataStatic().descriptor;
2751 }
2752 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2753 return GetMetadataStatic().reflection;
2754 }
2755 static const ReportErrorToServiceResponse& default_instance();
2756
2757 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2758 static inline const ReportErrorToServiceResponse* internal_default_instance() {
2759 return reinterpret_cast<const ReportErrorToServiceResponse*>(
2760 &_ReportErrorToServiceResponse_default_instance_);
2761 }
2762 static constexpr int kIndexInFileMessages =
2763 18;
2764
2765 friend void swap(ReportErrorToServiceResponse& a, ReportErrorToServiceResponse& b) {
2766 a.Swap(&b);
2767 }
2768 inline void Swap(ReportErrorToServiceResponse* other) {
2769 if (other == this) return;
2770 InternalSwap(other);
2771 }
2772
2773 // implements Message ----------------------------------------------
2774
2775 inline ReportErrorToServiceResponse* New() const final {
2776 return CreateMaybeMessage<ReportErrorToServiceResponse>(nullptr);
2777 }
2778
2779 ReportErrorToServiceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2780 return CreateMaybeMessage<ReportErrorToServiceResponse>(arena);
2781 }
2782 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2783 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2784 void CopyFrom(const ReportErrorToServiceResponse& from);
2785 void MergeFrom(const ReportErrorToServiceResponse& from);
2786 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2787 bool IsInitialized() const final;
2788
2789 size_t ByteSizeLong() const final;
2790 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2791 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2792 #else
2793 bool MergePartialFromCodedStream(
2794 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2795 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2796 void SerializeWithCachedSizes(
2797 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2798 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2799 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2800 int GetCachedSize() const final { return _cached_size_.Get(); }
2801
2802 private:
2803 inline void SharedCtor();
2804 inline void SharedDtor();
2805 void SetCachedSize(int size) const final;
2806 void InternalSwap(ReportErrorToServiceResponse* other);
2807 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2808 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2809 return "tensorflow.ReportErrorToServiceResponse";
2810 }
2811 private:
2812 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2813 return nullptr;
2814 }
2815 inline void* MaybeArenaPtr() const {
2816 return nullptr;
2817 }
2818 public:
2819
2820 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2821 private:
2822 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2823 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2824 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2825 }
2826
2827 public:
2828
2829 // nested types ----------------------------------------------------
2830
2831 // accessors -------------------------------------------------------
2832
2833 // @@protoc_insertion_point(class_scope:tensorflow.ReportErrorToServiceResponse)
2834 private:
2835 class _Internal;
2836
2837 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2838 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2839 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2840};
2841// -------------------------------------------------------------------
2842
2843class KeyValueEntry :
2844 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.KeyValueEntry) */ {
2845 public:
2846 KeyValueEntry();
2847 virtual ~KeyValueEntry();
2848
2849 KeyValueEntry(const KeyValueEntry& from);
2850 KeyValueEntry(KeyValueEntry&& from) noexcept
2851 : KeyValueEntry() {
2852 *this = ::std::move(from);
2853 }
2854
2855 inline KeyValueEntry& operator=(const KeyValueEntry& from) {
2856 CopyFrom(from);
2857 return *this;
2858 }
2859 inline KeyValueEntry& operator=(KeyValueEntry&& from) noexcept {
2860 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2861 if (this != &from) InternalSwap(&from);
2862 } else {
2863 CopyFrom(from);
2864 }
2865 return *this;
2866 }
2867
2868 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2869 return GetDescriptor();
2870 }
2871 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2872 return GetMetadataStatic().descriptor;
2873 }
2874 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2875 return GetMetadataStatic().reflection;
2876 }
2877 static const KeyValueEntry& default_instance();
2878
2879 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2880 static inline const KeyValueEntry* internal_default_instance() {
2881 return reinterpret_cast<const KeyValueEntry*>(
2882 &_KeyValueEntry_default_instance_);
2883 }
2884 static constexpr int kIndexInFileMessages =
2885 19;
2886
2887 friend void swap(KeyValueEntry& a, KeyValueEntry& b) {
2888 a.Swap(&b);
2889 }
2890 inline void Swap(KeyValueEntry* other) {
2891 if (other == this) return;
2892 InternalSwap(other);
2893 }
2894
2895 // implements Message ----------------------------------------------
2896
2897 inline KeyValueEntry* New() const final {
2898 return CreateMaybeMessage<KeyValueEntry>(nullptr);
2899 }
2900
2901 KeyValueEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2902 return CreateMaybeMessage<KeyValueEntry>(arena);
2903 }
2904 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2905 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2906 void CopyFrom(const KeyValueEntry& from);
2907 void MergeFrom(const KeyValueEntry& from);
2908 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2909 bool IsInitialized() const final;
2910
2911 size_t ByteSizeLong() const final;
2912 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2913 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2914 #else
2915 bool MergePartialFromCodedStream(
2916 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2917 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2918 void SerializeWithCachedSizes(
2919 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2920 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2921 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2922 int GetCachedSize() const final { return _cached_size_.Get(); }
2923
2924 private:
2925 inline void SharedCtor();
2926 inline void SharedDtor();
2927 void SetCachedSize(int size) const final;
2928 void InternalSwap(KeyValueEntry* other);
2929 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2930 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2931 return "tensorflow.KeyValueEntry";
2932 }
2933 private:
2934 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2935 return nullptr;
2936 }
2937 inline void* MaybeArenaPtr() const {
2938 return nullptr;
2939 }
2940 public:
2941
2942 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2943 private:
2944 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2945 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
2946 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
2947 }
2948
2949 public:
2950
2951 // nested types ----------------------------------------------------
2952
2953 // accessors -------------------------------------------------------
2954
2955 enum : int {
2956 kKeyFieldNumber = 1,
2957 kValueFieldNumber = 2,
2958 };
2959 // string key = 1;
2960 void clear_key();
2961 const std::string& key() const;
2962 void set_key(const std::string& value);
2963 void set_key(std::string&& value);
2964 void set_key(const char* value);
2965 void set_key(const char* value, size_t size);
2966 std::string* mutable_key();
2967 std::string* release_key();
2968 void set_allocated_key(std::string* key);
2969
2970 // bytes value = 2;
2971 void clear_value();
2972 const std::string& value() const;
2973 void set_value(const std::string& value);
2974 void set_value(std::string&& value);
2975 void set_value(const char* value);
2976 void set_value(const void* value, size_t size);
2977 std::string* mutable_value();
2978 std::string* release_value();
2979 void set_allocated_value(std::string* value);
2980
2981 // @@protoc_insertion_point(class_scope:tensorflow.KeyValueEntry)
2982 private:
2983 class _Internal;
2984
2985 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2986 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
2987 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
2988 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2989 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
2990};
2991// -------------------------------------------------------------------
2992
2993class InsertKeyValueRequest :
2994 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.InsertKeyValueRequest) */ {
2995 public:
2996 InsertKeyValueRequest();
2997 virtual ~InsertKeyValueRequest();
2998
2999 InsertKeyValueRequest(const InsertKeyValueRequest& from);
3000 InsertKeyValueRequest(InsertKeyValueRequest&& from) noexcept
3001 : InsertKeyValueRequest() {
3002 *this = ::std::move(from);
3003 }
3004
3005 inline InsertKeyValueRequest& operator=(const InsertKeyValueRequest& from) {
3006 CopyFrom(from);
3007 return *this;
3008 }
3009 inline InsertKeyValueRequest& operator=(InsertKeyValueRequest&& from) noexcept {
3010 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3011 if (this != &from) InternalSwap(&from);
3012 } else {
3013 CopyFrom(from);
3014 }
3015 return *this;
3016 }
3017
3018 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3019 return GetDescriptor();
3020 }
3021 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3022 return GetMetadataStatic().descriptor;
3023 }
3024 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3025 return GetMetadataStatic().reflection;
3026 }
3027 static const InsertKeyValueRequest& default_instance();
3028
3029 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3030 static inline const InsertKeyValueRequest* internal_default_instance() {
3031 return reinterpret_cast<const InsertKeyValueRequest*>(
3032 &_InsertKeyValueRequest_default_instance_);
3033 }
3034 static constexpr int kIndexInFileMessages =
3035 20;
3036
3037 friend void swap(InsertKeyValueRequest& a, InsertKeyValueRequest& b) {
3038 a.Swap(&b);
3039 }
3040 inline void Swap(InsertKeyValueRequest* other) {
3041 if (other == this) return;
3042 InternalSwap(other);
3043 }
3044
3045 // implements Message ----------------------------------------------
3046
3047 inline InsertKeyValueRequest* New() const final {
3048 return CreateMaybeMessage<InsertKeyValueRequest>(nullptr);
3049 }
3050
3051 InsertKeyValueRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3052 return CreateMaybeMessage<InsertKeyValueRequest>(arena);
3053 }
3054 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3055 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3056 void CopyFrom(const InsertKeyValueRequest& from);
3057 void MergeFrom(const InsertKeyValueRequest& from);
3058 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3059 bool IsInitialized() const final;
3060
3061 size_t ByteSizeLong() const final;
3062 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3063 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3064 #else
3065 bool MergePartialFromCodedStream(
3066 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3067 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3068 void SerializeWithCachedSizes(
3069 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3070 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3071 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3072 int GetCachedSize() const final { return _cached_size_.Get(); }
3073
3074 private:
3075 inline void SharedCtor();
3076 inline void SharedDtor();
3077 void SetCachedSize(int size) const final;
3078 void InternalSwap(InsertKeyValueRequest* other);
3079 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3080 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3081 return "tensorflow.InsertKeyValueRequest";
3082 }
3083 private:
3084 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3085 return nullptr;
3086 }
3087 inline void* MaybeArenaPtr() const {
3088 return nullptr;
3089 }
3090 public:
3091
3092 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3093 private:
3094 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3095 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3096 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3097 }
3098
3099 public:
3100
3101 // nested types ----------------------------------------------------
3102
3103 // accessors -------------------------------------------------------
3104
3105 enum : int {
3106 kKvFieldNumber = 1,
3107 };
3108 // .tensorflow.KeyValueEntry kv = 1;
3109 bool has_kv() const;
3110 void clear_kv();
3111 const ::tensorflow::KeyValueEntry& kv() const;
3112 ::tensorflow::KeyValueEntry* release_kv();
3113 ::tensorflow::KeyValueEntry* mutable_kv();
3114 void set_allocated_kv(::tensorflow::KeyValueEntry* kv);
3115
3116 // @@protoc_insertion_point(class_scope:tensorflow.InsertKeyValueRequest)
3117 private:
3118 class _Internal;
3119
3120 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3121 ::tensorflow::KeyValueEntry* kv_;
3122 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3123 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3124};
3125// -------------------------------------------------------------------
3126
3127class InsertKeyValueResponse :
3128 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.InsertKeyValueResponse) */ {
3129 public:
3130 InsertKeyValueResponse();
3131 virtual ~InsertKeyValueResponse();
3132
3133 InsertKeyValueResponse(const InsertKeyValueResponse& from);
3134 InsertKeyValueResponse(InsertKeyValueResponse&& from) noexcept
3135 : InsertKeyValueResponse() {
3136 *this = ::std::move(from);
3137 }
3138
3139 inline InsertKeyValueResponse& operator=(const InsertKeyValueResponse& from) {
3140 CopyFrom(from);
3141 return *this;
3142 }
3143 inline InsertKeyValueResponse& operator=(InsertKeyValueResponse&& from) noexcept {
3144 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3145 if (this != &from) InternalSwap(&from);
3146 } else {
3147 CopyFrom(from);
3148 }
3149 return *this;
3150 }
3151
3152 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3153 return GetDescriptor();
3154 }
3155 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3156 return GetMetadataStatic().descriptor;
3157 }
3158 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3159 return GetMetadataStatic().reflection;
3160 }
3161 static const InsertKeyValueResponse& default_instance();
3162
3163 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3164 static inline const InsertKeyValueResponse* internal_default_instance() {
3165 return reinterpret_cast<const InsertKeyValueResponse*>(
3166 &_InsertKeyValueResponse_default_instance_);
3167 }
3168 static constexpr int kIndexInFileMessages =
3169 21;
3170
3171 friend void swap(InsertKeyValueResponse& a, InsertKeyValueResponse& b) {
3172 a.Swap(&b);
3173 }
3174 inline void Swap(InsertKeyValueResponse* other) {
3175 if (other == this) return;
3176 InternalSwap(other);
3177 }
3178
3179 // implements Message ----------------------------------------------
3180
3181 inline InsertKeyValueResponse* New() const final {
3182 return CreateMaybeMessage<InsertKeyValueResponse>(nullptr);
3183 }
3184
3185 InsertKeyValueResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3186 return CreateMaybeMessage<InsertKeyValueResponse>(arena);
3187 }
3188 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3189 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3190 void CopyFrom(const InsertKeyValueResponse& from);
3191 void MergeFrom(const InsertKeyValueResponse& from);
3192 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3193 bool IsInitialized() const final;
3194
3195 size_t ByteSizeLong() const final;
3196 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3197 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3198 #else
3199 bool MergePartialFromCodedStream(
3200 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3201 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3202 void SerializeWithCachedSizes(
3203 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3204 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3205 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3206 int GetCachedSize() const final { return _cached_size_.Get(); }
3207
3208 private:
3209 inline void SharedCtor();
3210 inline void SharedDtor();
3211 void SetCachedSize(int size) const final;
3212 void InternalSwap(InsertKeyValueResponse* other);
3213 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3214 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3215 return "tensorflow.InsertKeyValueResponse";
3216 }
3217 private:
3218 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3219 return nullptr;
3220 }
3221 inline void* MaybeArenaPtr() const {
3222 return nullptr;
3223 }
3224 public:
3225
3226 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3227 private:
3228 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3229 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3230 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3231 }
3232
3233 public:
3234
3235 // nested types ----------------------------------------------------
3236
3237 // accessors -------------------------------------------------------
3238
3239 // @@protoc_insertion_point(class_scope:tensorflow.InsertKeyValueResponse)
3240 private:
3241 class _Internal;
3242
3243 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3244 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3245 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3246};
3247// -------------------------------------------------------------------
3248
3249class GetKeyValueRequest :
3250 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GetKeyValueRequest) */ {
3251 public:
3252 GetKeyValueRequest();
3253 virtual ~GetKeyValueRequest();
3254
3255 GetKeyValueRequest(const GetKeyValueRequest& from);
3256 GetKeyValueRequest(GetKeyValueRequest&& from) noexcept
3257 : GetKeyValueRequest() {
3258 *this = ::std::move(from);
3259 }
3260
3261 inline GetKeyValueRequest& operator=(const GetKeyValueRequest& from) {
3262 CopyFrom(from);
3263 return *this;
3264 }
3265 inline GetKeyValueRequest& operator=(GetKeyValueRequest&& from) noexcept {
3266 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3267 if (this != &from) InternalSwap(&from);
3268 } else {
3269 CopyFrom(from);
3270 }
3271 return *this;
3272 }
3273
3274 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3275 return GetDescriptor();
3276 }
3277 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3278 return GetMetadataStatic().descriptor;
3279 }
3280 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3281 return GetMetadataStatic().reflection;
3282 }
3283 static const GetKeyValueRequest& default_instance();
3284
3285 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3286 static inline const GetKeyValueRequest* internal_default_instance() {
3287 return reinterpret_cast<const GetKeyValueRequest*>(
3288 &_GetKeyValueRequest_default_instance_);
3289 }
3290 static constexpr int kIndexInFileMessages =
3291 22;
3292
3293 friend void swap(GetKeyValueRequest& a, GetKeyValueRequest& b) {
3294 a.Swap(&b);
3295 }
3296 inline void Swap(GetKeyValueRequest* other) {
3297 if (other == this) return;
3298 InternalSwap(other);
3299 }
3300
3301 // implements Message ----------------------------------------------
3302
3303 inline GetKeyValueRequest* New() const final {
3304 return CreateMaybeMessage<GetKeyValueRequest>(nullptr);
3305 }
3306
3307 GetKeyValueRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3308 return CreateMaybeMessage<GetKeyValueRequest>(arena);
3309 }
3310 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3311 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3312 void CopyFrom(const GetKeyValueRequest& from);
3313 void MergeFrom(const GetKeyValueRequest& from);
3314 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3315 bool IsInitialized() const final;
3316
3317 size_t ByteSizeLong() const final;
3318 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3319 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3320 #else
3321 bool MergePartialFromCodedStream(
3322 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3323 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3324 void SerializeWithCachedSizes(
3325 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3326 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3327 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3328 int GetCachedSize() const final { return _cached_size_.Get(); }
3329
3330 private:
3331 inline void SharedCtor();
3332 inline void SharedDtor();
3333 void SetCachedSize(int size) const final;
3334 void InternalSwap(GetKeyValueRequest* other);
3335 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3336 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3337 return "tensorflow.GetKeyValueRequest";
3338 }
3339 private:
3340 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3341 return nullptr;
3342 }
3343 inline void* MaybeArenaPtr() const {
3344 return nullptr;
3345 }
3346 public:
3347
3348 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3349 private:
3350 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3351 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3352 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3353 }
3354
3355 public:
3356
3357 // nested types ----------------------------------------------------
3358
3359 // accessors -------------------------------------------------------
3360
3361 enum : int {
3362 kKeyFieldNumber = 1,
3363 };
3364 // string key = 1;
3365 void clear_key();
3366 const std::string& key() const;
3367 void set_key(const std::string& value);
3368 void set_key(std::string&& value);
3369 void set_key(const char* value);
3370 void set_key(const char* value, size_t size);
3371 std::string* mutable_key();
3372 std::string* release_key();
3373 void set_allocated_key(std::string* key);
3374
3375 // @@protoc_insertion_point(class_scope:tensorflow.GetKeyValueRequest)
3376 private:
3377 class _Internal;
3378
3379 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3380 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
3381 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3382 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3383};
3384// -------------------------------------------------------------------
3385
3386class GetKeyValueResponse :
3387 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GetKeyValueResponse) */ {
3388 public:
3389 GetKeyValueResponse();
3390 virtual ~GetKeyValueResponse();
3391
3392 GetKeyValueResponse(const GetKeyValueResponse& from);
3393 GetKeyValueResponse(GetKeyValueResponse&& from) noexcept
3394 : GetKeyValueResponse() {
3395 *this = ::std::move(from);
3396 }
3397
3398 inline GetKeyValueResponse& operator=(const GetKeyValueResponse& from) {
3399 CopyFrom(from);
3400 return *this;
3401 }
3402 inline GetKeyValueResponse& operator=(GetKeyValueResponse&& from) noexcept {
3403 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3404 if (this != &from) InternalSwap(&from);
3405 } else {
3406 CopyFrom(from);
3407 }
3408 return *this;
3409 }
3410
3411 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3412 return GetDescriptor();
3413 }
3414 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3415 return GetMetadataStatic().descriptor;
3416 }
3417 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3418 return GetMetadataStatic().reflection;
3419 }
3420 static const GetKeyValueResponse& default_instance();
3421
3422 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3423 static inline const GetKeyValueResponse* internal_default_instance() {
3424 return reinterpret_cast<const GetKeyValueResponse*>(
3425 &_GetKeyValueResponse_default_instance_);
3426 }
3427 static constexpr int kIndexInFileMessages =
3428 23;
3429
3430 friend void swap(GetKeyValueResponse& a, GetKeyValueResponse& b) {
3431 a.Swap(&b);
3432 }
3433 inline void Swap(GetKeyValueResponse* other) {
3434 if (other == this) return;
3435 InternalSwap(other);
3436 }
3437
3438 // implements Message ----------------------------------------------
3439
3440 inline GetKeyValueResponse* New() const final {
3441 return CreateMaybeMessage<GetKeyValueResponse>(nullptr);
3442 }
3443
3444 GetKeyValueResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3445 return CreateMaybeMessage<GetKeyValueResponse>(arena);
3446 }
3447 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3448 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3449 void CopyFrom(const GetKeyValueResponse& from);
3450 void MergeFrom(const GetKeyValueResponse& from);
3451 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3452 bool IsInitialized() const final;
3453
3454 size_t ByteSizeLong() const final;
3455 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3456 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3457 #else
3458 bool MergePartialFromCodedStream(
3459 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3460 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3461 void SerializeWithCachedSizes(
3462 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3463 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3464 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3465 int GetCachedSize() const final { return _cached_size_.Get(); }
3466
3467 private:
3468 inline void SharedCtor();
3469 inline void SharedDtor();
3470 void SetCachedSize(int size) const final;
3471 void InternalSwap(GetKeyValueResponse* other);
3472 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3473 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3474 return "tensorflow.GetKeyValueResponse";
3475 }
3476 private:
3477 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3478 return nullptr;
3479 }
3480 inline void* MaybeArenaPtr() const {
3481 return nullptr;
3482 }
3483 public:
3484
3485 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3486 private:
3487 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3488 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3489 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3490 }
3491
3492 public:
3493
3494 // nested types ----------------------------------------------------
3495
3496 // accessors -------------------------------------------------------
3497
3498 enum : int {
3499 kKvFieldNumber = 1,
3500 };
3501 // .tensorflow.KeyValueEntry kv = 1;
3502 bool has_kv() const;
3503 void clear_kv();
3504 const ::tensorflow::KeyValueEntry& kv() const;
3505 ::tensorflow::KeyValueEntry* release_kv();
3506 ::tensorflow::KeyValueEntry* mutable_kv();
3507 void set_allocated_kv(::tensorflow::KeyValueEntry* kv);
3508
3509 // @@protoc_insertion_point(class_scope:tensorflow.GetKeyValueResponse)
3510 private:
3511 class _Internal;
3512
3513 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3514 ::tensorflow::KeyValueEntry* kv_;
3515 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3516 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3517};
3518// -------------------------------------------------------------------
3519
3520class TryGetKeyValueRequest :
3521 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TryGetKeyValueRequest) */ {
3522 public:
3523 TryGetKeyValueRequest();
3524 virtual ~TryGetKeyValueRequest();
3525
3526 TryGetKeyValueRequest(const TryGetKeyValueRequest& from);
3527 TryGetKeyValueRequest(TryGetKeyValueRequest&& from) noexcept
3528 : TryGetKeyValueRequest() {
3529 *this = ::std::move(from);
3530 }
3531
3532 inline TryGetKeyValueRequest& operator=(const TryGetKeyValueRequest& from) {
3533 CopyFrom(from);
3534 return *this;
3535 }
3536 inline TryGetKeyValueRequest& operator=(TryGetKeyValueRequest&& from) noexcept {
3537 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3538 if (this != &from) InternalSwap(&from);
3539 } else {
3540 CopyFrom(from);
3541 }
3542 return *this;
3543 }
3544
3545 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3546 return GetDescriptor();
3547 }
3548 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3549 return GetMetadataStatic().descriptor;
3550 }
3551 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3552 return GetMetadataStatic().reflection;
3553 }
3554 static const TryGetKeyValueRequest& default_instance();
3555
3556 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3557 static inline const TryGetKeyValueRequest* internal_default_instance() {
3558 return reinterpret_cast<const TryGetKeyValueRequest*>(
3559 &_TryGetKeyValueRequest_default_instance_);
3560 }
3561 static constexpr int kIndexInFileMessages =
3562 24;
3563
3564 friend void swap(TryGetKeyValueRequest& a, TryGetKeyValueRequest& b) {
3565 a.Swap(&b);
3566 }
3567 inline void Swap(TryGetKeyValueRequest* other) {
3568 if (other == this) return;
3569 InternalSwap(other);
3570 }
3571
3572 // implements Message ----------------------------------------------
3573
3574 inline TryGetKeyValueRequest* New() const final {
3575 return CreateMaybeMessage<TryGetKeyValueRequest>(nullptr);
3576 }
3577
3578 TryGetKeyValueRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3579 return CreateMaybeMessage<TryGetKeyValueRequest>(arena);
3580 }
3581 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3582 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3583 void CopyFrom(const TryGetKeyValueRequest& from);
3584 void MergeFrom(const TryGetKeyValueRequest& from);
3585 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3586 bool IsInitialized() const final;
3587
3588 size_t ByteSizeLong() const final;
3589 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3590 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3591 #else
3592 bool MergePartialFromCodedStream(
3593 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3594 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3595 void SerializeWithCachedSizes(
3596 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3597 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3598 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3599 int GetCachedSize() const final { return _cached_size_.Get(); }
3600
3601 private:
3602 inline void SharedCtor();
3603 inline void SharedDtor();
3604 void SetCachedSize(int size) const final;
3605 void InternalSwap(TryGetKeyValueRequest* other);
3606 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3607 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3608 return "tensorflow.TryGetKeyValueRequest";
3609 }
3610 private:
3611 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3612 return nullptr;
3613 }
3614 inline void* MaybeArenaPtr() const {
3615 return nullptr;
3616 }
3617 public:
3618
3619 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3620 private:
3621 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3622 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3623 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3624 }
3625
3626 public:
3627
3628 // nested types ----------------------------------------------------
3629
3630 // accessors -------------------------------------------------------
3631
3632 enum : int {
3633 kKeyFieldNumber = 1,
3634 };
3635 // string key = 1;
3636 void clear_key();
3637 const std::string& key() const;
3638 void set_key(const std::string& value);
3639 void set_key(std::string&& value);
3640 void set_key(const char* value);
3641 void set_key(const char* value, size_t size);
3642 std::string* mutable_key();
3643 std::string* release_key();
3644 void set_allocated_key(std::string* key);
3645
3646 // @@protoc_insertion_point(class_scope:tensorflow.TryGetKeyValueRequest)
3647 private:
3648 class _Internal;
3649
3650 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3651 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
3652 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3653 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3654};
3655// -------------------------------------------------------------------
3656
3657class TryGetKeyValueResponse :
3658 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.TryGetKeyValueResponse) */ {
3659 public:
3660 TryGetKeyValueResponse();
3661 virtual ~TryGetKeyValueResponse();
3662
3663 TryGetKeyValueResponse(const TryGetKeyValueResponse& from);
3664 TryGetKeyValueResponse(TryGetKeyValueResponse&& from) noexcept
3665 : TryGetKeyValueResponse() {
3666 *this = ::std::move(from);
3667 }
3668
3669 inline TryGetKeyValueResponse& operator=(const TryGetKeyValueResponse& from) {
3670 CopyFrom(from);
3671 return *this;
3672 }
3673 inline TryGetKeyValueResponse& operator=(TryGetKeyValueResponse&& from) noexcept {
3674 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3675 if (this != &from) InternalSwap(&from);
3676 } else {
3677 CopyFrom(from);
3678 }
3679 return *this;
3680 }
3681
3682 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3683 return GetDescriptor();
3684 }
3685 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3686 return GetMetadataStatic().descriptor;
3687 }
3688 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3689 return GetMetadataStatic().reflection;
3690 }
3691 static const TryGetKeyValueResponse& default_instance();
3692
3693 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3694 static inline const TryGetKeyValueResponse* internal_default_instance() {
3695 return reinterpret_cast<const TryGetKeyValueResponse*>(
3696 &_TryGetKeyValueResponse_default_instance_);
3697 }
3698 static constexpr int kIndexInFileMessages =
3699 25;
3700
3701 friend void swap(TryGetKeyValueResponse& a, TryGetKeyValueResponse& b) {
3702 a.Swap(&b);
3703 }
3704 inline void Swap(TryGetKeyValueResponse* other) {
3705 if (other == this) return;
3706 InternalSwap(other);
3707 }
3708
3709 // implements Message ----------------------------------------------
3710
3711 inline TryGetKeyValueResponse* New() const final {
3712 return CreateMaybeMessage<TryGetKeyValueResponse>(nullptr);
3713 }
3714
3715 TryGetKeyValueResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3716 return CreateMaybeMessage<TryGetKeyValueResponse>(arena);
3717 }
3718 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3719 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3720 void CopyFrom(const TryGetKeyValueResponse& from);
3721 void MergeFrom(const TryGetKeyValueResponse& from);
3722 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3723 bool IsInitialized() const final;
3724
3725 size_t ByteSizeLong() const final;
3726 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3727 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3728 #else
3729 bool MergePartialFromCodedStream(
3730 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3731 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3732 void SerializeWithCachedSizes(
3733 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3734 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3735 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3736 int GetCachedSize() const final { return _cached_size_.Get(); }
3737
3738 private:
3739 inline void SharedCtor();
3740 inline void SharedDtor();
3741 void SetCachedSize(int size) const final;
3742 void InternalSwap(TryGetKeyValueResponse* other);
3743 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3744 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3745 return "tensorflow.TryGetKeyValueResponse";
3746 }
3747 private:
3748 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3749 return nullptr;
3750 }
3751 inline void* MaybeArenaPtr() const {
3752 return nullptr;
3753 }
3754 public:
3755
3756 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3757 private:
3758 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3759 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3760 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3761 }
3762
3763 public:
3764
3765 // nested types ----------------------------------------------------
3766
3767 // accessors -------------------------------------------------------
3768
3769 enum : int {
3770 kKvFieldNumber = 1,
3771 };
3772 // .tensorflow.KeyValueEntry kv = 1;
3773 bool has_kv() const;
3774 void clear_kv();
3775 const ::tensorflow::KeyValueEntry& kv() const;
3776 ::tensorflow::KeyValueEntry* release_kv();
3777 ::tensorflow::KeyValueEntry* mutable_kv();
3778 void set_allocated_kv(::tensorflow::KeyValueEntry* kv);
3779
3780 // @@protoc_insertion_point(class_scope:tensorflow.TryGetKeyValueResponse)
3781 private:
3782 class _Internal;
3783
3784 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3785 ::tensorflow::KeyValueEntry* kv_;
3786 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3787 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3788};
3789// -------------------------------------------------------------------
3790
3791class GetKeyValueDirRequest :
3792 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GetKeyValueDirRequest) */ {
3793 public:
3794 GetKeyValueDirRequest();
3795 virtual ~GetKeyValueDirRequest();
3796
3797 GetKeyValueDirRequest(const GetKeyValueDirRequest& from);
3798 GetKeyValueDirRequest(GetKeyValueDirRequest&& from) noexcept
3799 : GetKeyValueDirRequest() {
3800 *this = ::std::move(from);
3801 }
3802
3803 inline GetKeyValueDirRequest& operator=(const GetKeyValueDirRequest& from) {
3804 CopyFrom(from);
3805 return *this;
3806 }
3807 inline GetKeyValueDirRequest& operator=(GetKeyValueDirRequest&& from) noexcept {
3808 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3809 if (this != &from) InternalSwap(&from);
3810 } else {
3811 CopyFrom(from);
3812 }
3813 return *this;
3814 }
3815
3816 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3817 return GetDescriptor();
3818 }
3819 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3820 return GetMetadataStatic().descriptor;
3821 }
3822 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3823 return GetMetadataStatic().reflection;
3824 }
3825 static const GetKeyValueDirRequest& default_instance();
3826
3827 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3828 static inline const GetKeyValueDirRequest* internal_default_instance() {
3829 return reinterpret_cast<const GetKeyValueDirRequest*>(
3830 &_GetKeyValueDirRequest_default_instance_);
3831 }
3832 static constexpr int kIndexInFileMessages =
3833 26;
3834
3835 friend void swap(GetKeyValueDirRequest& a, GetKeyValueDirRequest& b) {
3836 a.Swap(&b);
3837 }
3838 inline void Swap(GetKeyValueDirRequest* other) {
3839 if (other == this) return;
3840 InternalSwap(other);
3841 }
3842
3843 // implements Message ----------------------------------------------
3844
3845 inline GetKeyValueDirRequest* New() const final {
3846 return CreateMaybeMessage<GetKeyValueDirRequest>(nullptr);
3847 }
3848
3849 GetKeyValueDirRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3850 return CreateMaybeMessage<GetKeyValueDirRequest>(arena);
3851 }
3852 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3853 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3854 void CopyFrom(const GetKeyValueDirRequest& from);
3855 void MergeFrom(const GetKeyValueDirRequest& from);
3856 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3857 bool IsInitialized() const final;
3858
3859 size_t ByteSizeLong() const final;
3860 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3861 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3862 #else
3863 bool MergePartialFromCodedStream(
3864 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
3865 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3866 void SerializeWithCachedSizes(
3867 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
3868 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
3869 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
3870 int GetCachedSize() const final { return _cached_size_.Get(); }
3871
3872 private:
3873 inline void SharedCtor();
3874 inline void SharedDtor();
3875 void SetCachedSize(int size) const final;
3876 void InternalSwap(GetKeyValueDirRequest* other);
3877 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3878 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3879 return "tensorflow.GetKeyValueDirRequest";
3880 }
3881 private:
3882 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
3883 return nullptr;
3884 }
3885 inline void* MaybeArenaPtr() const {
3886 return nullptr;
3887 }
3888 public:
3889
3890 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
3891 private:
3892 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
3893 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
3894 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
3895 }
3896
3897 public:
3898
3899 // nested types ----------------------------------------------------
3900
3901 // accessors -------------------------------------------------------
3902
3903 enum : int {
3904 kDirectoryKeyFieldNumber = 1,
3905 };
3906 // string directory_key = 1;
3907 void clear_directory_key();
3908 const std::string& directory_key() const;
3909 void set_directory_key(const std::string& value);
3910 void set_directory_key(std::string&& value);
3911 void set_directory_key(const char* value);
3912 void set_directory_key(const char* value, size_t size);
3913 std::string* mutable_directory_key();
3914 std::string* release_directory_key();
3915 void set_allocated_directory_key(std::string* directory_key);
3916
3917 // @@protoc_insertion_point(class_scope:tensorflow.GetKeyValueDirRequest)
3918 private:
3919 class _Internal;
3920
3921 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
3922 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directory_key_;
3923 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3924 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
3925};
3926// -------------------------------------------------------------------
3927
3928class GetKeyValueDirResponse :
3929 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GetKeyValueDirResponse) */ {
3930 public:
3931 GetKeyValueDirResponse();
3932 virtual ~GetKeyValueDirResponse();
3933
3934 GetKeyValueDirResponse(const GetKeyValueDirResponse& from);
3935 GetKeyValueDirResponse(GetKeyValueDirResponse&& from) noexcept
3936 : GetKeyValueDirResponse() {
3937 *this = ::std::move(from);
3938 }
3939
3940 inline GetKeyValueDirResponse& operator=(const GetKeyValueDirResponse& from) {
3941 CopyFrom(from);
3942 return *this;
3943 }
3944 inline GetKeyValueDirResponse& operator=(GetKeyValueDirResponse&& from) noexcept {
3945 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
3946 if (this != &from) InternalSwap(&from);
3947 } else {
3948 CopyFrom(from);
3949 }
3950 return *this;
3951 }
3952
3953 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
3954 return GetDescriptor();
3955 }
3956 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
3957 return GetMetadataStatic().descriptor;
3958 }
3959 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
3960 return GetMetadataStatic().reflection;
3961 }
3962 static const GetKeyValueDirResponse& default_instance();
3963
3964 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
3965 static inline const GetKeyValueDirResponse* internal_default_instance() {
3966 return reinterpret_cast<const GetKeyValueDirResponse*>(
3967 &_GetKeyValueDirResponse_default_instance_);
3968 }
3969 static constexpr int kIndexInFileMessages =
3970 27;
3971
3972 friend void swap(GetKeyValueDirResponse& a, GetKeyValueDirResponse& b) {
3973 a.Swap(&b);
3974 }
3975 inline void Swap(GetKeyValueDirResponse* other) {
3976 if (other == this) return;
3977 InternalSwap(other);
3978 }
3979
3980 // implements Message ----------------------------------------------
3981
3982 inline GetKeyValueDirResponse* New() const final {
3983 return CreateMaybeMessage<GetKeyValueDirResponse>(nullptr);
3984 }
3985
3986 GetKeyValueDirResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3987 return CreateMaybeMessage<GetKeyValueDirResponse>(arena);
3988 }
3989 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3990 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
3991 void CopyFrom(const GetKeyValueDirResponse& from);
3992 void MergeFrom(const GetKeyValueDirResponse& from);
3993 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3994 bool IsInitialized() const final;
3995
3996 size_t ByteSizeLong() const final;
3997 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
3998 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3999 #else
4000 bool MergePartialFromCodedStream(
4001 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4002 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4003 void SerializeWithCachedSizes(
4004 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4005 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4006 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4007 int GetCachedSize() const final { return _cached_size_.Get(); }
4008
4009 private:
4010 inline void SharedCtor();
4011 inline void SharedDtor();
4012 void SetCachedSize(int size) const final;
4013 void InternalSwap(GetKeyValueDirResponse* other);
4014 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4015 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4016 return "tensorflow.GetKeyValueDirResponse";
4017 }
4018 private:
4019 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4020 return nullptr;
4021 }
4022 inline void* MaybeArenaPtr() const {
4023 return nullptr;
4024 }
4025 public:
4026
4027 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4028 private:
4029 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4030 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4031 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4032 }
4033
4034 public:
4035
4036 // nested types ----------------------------------------------------
4037
4038 // accessors -------------------------------------------------------
4039
4040 enum : int {
4041 kKvFieldNumber = 2,
4042 kDirectoryKeyFieldNumber = 1,
4043 };
4044 // repeated .tensorflow.KeyValueEntry kv = 2;
4045 int kv_size() const;
4046 void clear_kv();
4047 ::tensorflow::KeyValueEntry* mutable_kv(int index);
4048 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KeyValueEntry >*
4049 mutable_kv();
4050 const ::tensorflow::KeyValueEntry& kv(int index) const;
4051 ::tensorflow::KeyValueEntry* add_kv();
4052 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KeyValueEntry >&
4053 kv() const;
4054
4055 // string directory_key = 1;
4056 void clear_directory_key();
4057 const std::string& directory_key() const;
4058 void set_directory_key(const std::string& value);
4059 void set_directory_key(std::string&& value);
4060 void set_directory_key(const char* value);
4061 void set_directory_key(const char* value, size_t size);
4062 std::string* mutable_directory_key();
4063 std::string* release_directory_key();
4064 void set_allocated_directory_key(std::string* directory_key);
4065
4066 // @@protoc_insertion_point(class_scope:tensorflow.GetKeyValueDirResponse)
4067 private:
4068 class _Internal;
4069
4070 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4071 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KeyValueEntry > kv_;
4072 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr directory_key_;
4073 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4074 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4075};
4076// -------------------------------------------------------------------
4077
4078class DeleteKeyValueRequest :
4079 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DeleteKeyValueRequest) */ {
4080 public:
4081 DeleteKeyValueRequest();
4082 virtual ~DeleteKeyValueRequest();
4083
4084 DeleteKeyValueRequest(const DeleteKeyValueRequest& from);
4085 DeleteKeyValueRequest(DeleteKeyValueRequest&& from) noexcept
4086 : DeleteKeyValueRequest() {
4087 *this = ::std::move(from);
4088 }
4089
4090 inline DeleteKeyValueRequest& operator=(const DeleteKeyValueRequest& from) {
4091 CopyFrom(from);
4092 return *this;
4093 }
4094 inline DeleteKeyValueRequest& operator=(DeleteKeyValueRequest&& from) noexcept {
4095 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4096 if (this != &from) InternalSwap(&from);
4097 } else {
4098 CopyFrom(from);
4099 }
4100 return *this;
4101 }
4102
4103 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4104 return GetDescriptor();
4105 }
4106 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4107 return GetMetadataStatic().descriptor;
4108 }
4109 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4110 return GetMetadataStatic().reflection;
4111 }
4112 static const DeleteKeyValueRequest& default_instance();
4113
4114 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4115 static inline const DeleteKeyValueRequest* internal_default_instance() {
4116 return reinterpret_cast<const DeleteKeyValueRequest*>(
4117 &_DeleteKeyValueRequest_default_instance_);
4118 }
4119 static constexpr int kIndexInFileMessages =
4120 28;
4121
4122 friend void swap(DeleteKeyValueRequest& a, DeleteKeyValueRequest& b) {
4123 a.Swap(&b);
4124 }
4125 inline void Swap(DeleteKeyValueRequest* other) {
4126 if (other == this) return;
4127 InternalSwap(other);
4128 }
4129
4130 // implements Message ----------------------------------------------
4131
4132 inline DeleteKeyValueRequest* New() const final {
4133 return CreateMaybeMessage<DeleteKeyValueRequest>(nullptr);
4134 }
4135
4136 DeleteKeyValueRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4137 return CreateMaybeMessage<DeleteKeyValueRequest>(arena);
4138 }
4139 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4140 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4141 void CopyFrom(const DeleteKeyValueRequest& from);
4142 void MergeFrom(const DeleteKeyValueRequest& from);
4143 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4144 bool IsInitialized() const final;
4145
4146 size_t ByteSizeLong() const final;
4147 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4148 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4149 #else
4150 bool MergePartialFromCodedStream(
4151 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4152 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4153 void SerializeWithCachedSizes(
4154 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4155 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4156 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4157 int GetCachedSize() const final { return _cached_size_.Get(); }
4158
4159 private:
4160 inline void SharedCtor();
4161 inline void SharedDtor();
4162 void SetCachedSize(int size) const final;
4163 void InternalSwap(DeleteKeyValueRequest* other);
4164 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4165 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4166 return "tensorflow.DeleteKeyValueRequest";
4167 }
4168 private:
4169 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4170 return nullptr;
4171 }
4172 inline void* MaybeArenaPtr() const {
4173 return nullptr;
4174 }
4175 public:
4176
4177 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4178 private:
4179 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4180 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4181 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4182 }
4183
4184 public:
4185
4186 // nested types ----------------------------------------------------
4187
4188 // accessors -------------------------------------------------------
4189
4190 enum : int {
4191 kKeyFieldNumber = 1,
4192 kIsDirectoryFieldNumber = 2,
4193 };
4194 // string key = 1;
4195 void clear_key();
4196 const std::string& key() const;
4197 void set_key(const std::string& value);
4198 void set_key(std::string&& value);
4199 void set_key(const char* value);
4200 void set_key(const char* value, size_t size);
4201 std::string* mutable_key();
4202 std::string* release_key();
4203 void set_allocated_key(std::string* key);
4204
4205 // bool is_directory = 2;
4206 void clear_is_directory();
4207 bool is_directory() const;
4208 void set_is_directory(bool value);
4209
4210 // @@protoc_insertion_point(class_scope:tensorflow.DeleteKeyValueRequest)
4211 private:
4212 class _Internal;
4213
4214 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4215 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
4216 bool is_directory_;
4217 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4218 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4219};
4220// -------------------------------------------------------------------
4221
4222class DeleteKeyValueResponse :
4223 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DeleteKeyValueResponse) */ {
4224 public:
4225 DeleteKeyValueResponse();
4226 virtual ~DeleteKeyValueResponse();
4227
4228 DeleteKeyValueResponse(const DeleteKeyValueResponse& from);
4229 DeleteKeyValueResponse(DeleteKeyValueResponse&& from) noexcept
4230 : DeleteKeyValueResponse() {
4231 *this = ::std::move(from);
4232 }
4233
4234 inline DeleteKeyValueResponse& operator=(const DeleteKeyValueResponse& from) {
4235 CopyFrom(from);
4236 return *this;
4237 }
4238 inline DeleteKeyValueResponse& operator=(DeleteKeyValueResponse&& from) noexcept {
4239 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4240 if (this != &from) InternalSwap(&from);
4241 } else {
4242 CopyFrom(from);
4243 }
4244 return *this;
4245 }
4246
4247 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4248 return GetDescriptor();
4249 }
4250 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4251 return GetMetadataStatic().descriptor;
4252 }
4253 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4254 return GetMetadataStatic().reflection;
4255 }
4256 static const DeleteKeyValueResponse& default_instance();
4257
4258 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4259 static inline const DeleteKeyValueResponse* internal_default_instance() {
4260 return reinterpret_cast<const DeleteKeyValueResponse*>(
4261 &_DeleteKeyValueResponse_default_instance_);
4262 }
4263 static constexpr int kIndexInFileMessages =
4264 29;
4265
4266 friend void swap(DeleteKeyValueResponse& a, DeleteKeyValueResponse& b) {
4267 a.Swap(&b);
4268 }
4269 inline void Swap(DeleteKeyValueResponse* other) {
4270 if (other == this) return;
4271 InternalSwap(other);
4272 }
4273
4274 // implements Message ----------------------------------------------
4275
4276 inline DeleteKeyValueResponse* New() const final {
4277 return CreateMaybeMessage<DeleteKeyValueResponse>(nullptr);
4278 }
4279
4280 DeleteKeyValueResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4281 return CreateMaybeMessage<DeleteKeyValueResponse>(arena);
4282 }
4283 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4284 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4285 void CopyFrom(const DeleteKeyValueResponse& from);
4286 void MergeFrom(const DeleteKeyValueResponse& from);
4287 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4288 bool IsInitialized() const final;
4289
4290 size_t ByteSizeLong() const final;
4291 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4292 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4293 #else
4294 bool MergePartialFromCodedStream(
4295 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4296 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4297 void SerializeWithCachedSizes(
4298 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4299 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4300 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4301 int GetCachedSize() const final { return _cached_size_.Get(); }
4302
4303 private:
4304 inline void SharedCtor();
4305 inline void SharedDtor();
4306 void SetCachedSize(int size) const final;
4307 void InternalSwap(DeleteKeyValueResponse* other);
4308 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4309 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4310 return "tensorflow.DeleteKeyValueResponse";
4311 }
4312 private:
4313 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4314 return nullptr;
4315 }
4316 inline void* MaybeArenaPtr() const {
4317 return nullptr;
4318 }
4319 public:
4320
4321 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4322 private:
4323 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4324 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4325 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4326 }
4327
4328 public:
4329
4330 // nested types ----------------------------------------------------
4331
4332 // accessors -------------------------------------------------------
4333
4334 // @@protoc_insertion_point(class_scope:tensorflow.DeleteKeyValueResponse)
4335 private:
4336 class _Internal;
4337
4338 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4339 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4340 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4341};
4342// -------------------------------------------------------------------
4343
4344class BarrierRequest :
4345 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BarrierRequest) */ {
4346 public:
4347 BarrierRequest();
4348 virtual ~BarrierRequest();
4349
4350 BarrierRequest(const BarrierRequest& from);
4351 BarrierRequest(BarrierRequest&& from) noexcept
4352 : BarrierRequest() {
4353 *this = ::std::move(from);
4354 }
4355
4356 inline BarrierRequest& operator=(const BarrierRequest& from) {
4357 CopyFrom(from);
4358 return *this;
4359 }
4360 inline BarrierRequest& operator=(BarrierRequest&& from) noexcept {
4361 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4362 if (this != &from) InternalSwap(&from);
4363 } else {
4364 CopyFrom(from);
4365 }
4366 return *this;
4367 }
4368
4369 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4370 return GetDescriptor();
4371 }
4372 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4373 return GetMetadataStatic().descriptor;
4374 }
4375 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4376 return GetMetadataStatic().reflection;
4377 }
4378 static const BarrierRequest& default_instance();
4379
4380 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4381 static inline const BarrierRequest* internal_default_instance() {
4382 return reinterpret_cast<const BarrierRequest*>(
4383 &_BarrierRequest_default_instance_);
4384 }
4385 static constexpr int kIndexInFileMessages =
4386 30;
4387
4388 friend void swap(BarrierRequest& a, BarrierRequest& b) {
4389 a.Swap(&b);
4390 }
4391 inline void Swap(BarrierRequest* other) {
4392 if (other == this) return;
4393 InternalSwap(other);
4394 }
4395
4396 // implements Message ----------------------------------------------
4397
4398 inline BarrierRequest* New() const final {
4399 return CreateMaybeMessage<BarrierRequest>(nullptr);
4400 }
4401
4402 BarrierRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4403 return CreateMaybeMessage<BarrierRequest>(arena);
4404 }
4405 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4406 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4407 void CopyFrom(const BarrierRequest& from);
4408 void MergeFrom(const BarrierRequest& from);
4409 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4410 bool IsInitialized() const final;
4411
4412 size_t ByteSizeLong() const final;
4413 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4414 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4415 #else
4416 bool MergePartialFromCodedStream(
4417 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4418 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4419 void SerializeWithCachedSizes(
4420 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4421 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4422 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4423 int GetCachedSize() const final { return _cached_size_.Get(); }
4424
4425 private:
4426 inline void SharedCtor();
4427 inline void SharedDtor();
4428 void SetCachedSize(int size) const final;
4429 void InternalSwap(BarrierRequest* other);
4430 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4431 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4432 return "tensorflow.BarrierRequest";
4433 }
4434 private:
4435 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4436 return nullptr;
4437 }
4438 inline void* MaybeArenaPtr() const {
4439 return nullptr;
4440 }
4441 public:
4442
4443 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4444 private:
4445 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4446 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4447 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4448 }
4449
4450 public:
4451
4452 // nested types ----------------------------------------------------
4453
4454 // accessors -------------------------------------------------------
4455
4456 enum : int {
4457 kTasksFieldNumber = 3,
4458 kBarrierIdFieldNumber = 1,
4459 kSourceTaskFieldNumber = 4,
4460 kBarrierTimeoutInMsFieldNumber = 2,
4461 };
4462 // repeated .tensorflow.CoordinatedTask tasks = 3;
4463 int tasks_size() const;
4464 void clear_tasks();
4465 ::tensorflow::CoordinatedTask* mutable_tasks(int index);
4466 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CoordinatedTask >*
4467 mutable_tasks();
4468 const ::tensorflow::CoordinatedTask& tasks(int index) const;
4469 ::tensorflow::CoordinatedTask* add_tasks();
4470 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CoordinatedTask >&
4471 tasks() const;
4472
4473 // string barrier_id = 1;
4474 void clear_barrier_id();
4475 const std::string& barrier_id() const;
4476 void set_barrier_id(const std::string& value);
4477 void set_barrier_id(std::string&& value);
4478 void set_barrier_id(const char* value);
4479 void set_barrier_id(const char* value, size_t size);
4480 std::string* mutable_barrier_id();
4481 std::string* release_barrier_id();
4482 void set_allocated_barrier_id(std::string* barrier_id);
4483
4484 // .tensorflow.CoordinatedTask source_task = 4;
4485 bool has_source_task() const;
4486 void clear_source_task();
4487 const ::tensorflow::CoordinatedTask& source_task() const;
4488 ::tensorflow::CoordinatedTask* release_source_task();
4489 ::tensorflow::CoordinatedTask* mutable_source_task();
4490 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
4491
4492 // int64 barrier_timeout_in_ms = 2;
4493 void clear_barrier_timeout_in_ms();
4494 ::PROTOBUF_NAMESPACE_ID::int64 barrier_timeout_in_ms() const;
4495 void set_barrier_timeout_in_ms(::PROTOBUF_NAMESPACE_ID::int64 value);
4496
4497 // @@protoc_insertion_point(class_scope:tensorflow.BarrierRequest)
4498 private:
4499 class _Internal;
4500
4501 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4502 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CoordinatedTask > tasks_;
4503 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr barrier_id_;
4504 ::tensorflow::CoordinatedTask* source_task_;
4505 ::PROTOBUF_NAMESPACE_ID::int64 barrier_timeout_in_ms_;
4506 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4507 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4508};
4509// -------------------------------------------------------------------
4510
4511class BarrierResponse :
4512 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.BarrierResponse) */ {
4513 public:
4514 BarrierResponse();
4515 virtual ~BarrierResponse();
4516
4517 BarrierResponse(const BarrierResponse& from);
4518 BarrierResponse(BarrierResponse&& from) noexcept
4519 : BarrierResponse() {
4520 *this = ::std::move(from);
4521 }
4522
4523 inline BarrierResponse& operator=(const BarrierResponse& from) {
4524 CopyFrom(from);
4525 return *this;
4526 }
4527 inline BarrierResponse& operator=(BarrierResponse&& from) noexcept {
4528 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4529 if (this != &from) InternalSwap(&from);
4530 } else {
4531 CopyFrom(from);
4532 }
4533 return *this;
4534 }
4535
4536 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4537 return GetDescriptor();
4538 }
4539 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4540 return GetMetadataStatic().descriptor;
4541 }
4542 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4543 return GetMetadataStatic().reflection;
4544 }
4545 static const BarrierResponse& default_instance();
4546
4547 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4548 static inline const BarrierResponse* internal_default_instance() {
4549 return reinterpret_cast<const BarrierResponse*>(
4550 &_BarrierResponse_default_instance_);
4551 }
4552 static constexpr int kIndexInFileMessages =
4553 31;
4554
4555 friend void swap(BarrierResponse& a, BarrierResponse& b) {
4556 a.Swap(&b);
4557 }
4558 inline void Swap(BarrierResponse* other) {
4559 if (other == this) return;
4560 InternalSwap(other);
4561 }
4562
4563 // implements Message ----------------------------------------------
4564
4565 inline BarrierResponse* New() const final {
4566 return CreateMaybeMessage<BarrierResponse>(nullptr);
4567 }
4568
4569 BarrierResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4570 return CreateMaybeMessage<BarrierResponse>(arena);
4571 }
4572 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4573 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4574 void CopyFrom(const BarrierResponse& from);
4575 void MergeFrom(const BarrierResponse& from);
4576 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4577 bool IsInitialized() const final;
4578
4579 size_t ByteSizeLong() const final;
4580 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4581 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4582 #else
4583 bool MergePartialFromCodedStream(
4584 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4585 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4586 void SerializeWithCachedSizes(
4587 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4588 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4589 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4590 int GetCachedSize() const final { return _cached_size_.Get(); }
4591
4592 private:
4593 inline void SharedCtor();
4594 inline void SharedDtor();
4595 void SetCachedSize(int size) const final;
4596 void InternalSwap(BarrierResponse* other);
4597 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4598 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4599 return "tensorflow.BarrierResponse";
4600 }
4601 private:
4602 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4603 return nullptr;
4604 }
4605 inline void* MaybeArenaPtr() const {
4606 return nullptr;
4607 }
4608 public:
4609
4610 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4611 private:
4612 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4613 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4614 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4615 }
4616
4617 public:
4618
4619 // nested types ----------------------------------------------------
4620
4621 // accessors -------------------------------------------------------
4622
4623 // @@protoc_insertion_point(class_scope:tensorflow.BarrierResponse)
4624 private:
4625 class _Internal;
4626
4627 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4628 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4629 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4630};
4631// -------------------------------------------------------------------
4632
4633class CancelBarrierRequest :
4634 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CancelBarrierRequest) */ {
4635 public:
4636 CancelBarrierRequest();
4637 virtual ~CancelBarrierRequest();
4638
4639 CancelBarrierRequest(const CancelBarrierRequest& from);
4640 CancelBarrierRequest(CancelBarrierRequest&& from) noexcept
4641 : CancelBarrierRequest() {
4642 *this = ::std::move(from);
4643 }
4644
4645 inline CancelBarrierRequest& operator=(const CancelBarrierRequest& from) {
4646 CopyFrom(from);
4647 return *this;
4648 }
4649 inline CancelBarrierRequest& operator=(CancelBarrierRequest&& from) noexcept {
4650 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4651 if (this != &from) InternalSwap(&from);
4652 } else {
4653 CopyFrom(from);
4654 }
4655 return *this;
4656 }
4657
4658 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4659 return GetDescriptor();
4660 }
4661 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4662 return GetMetadataStatic().descriptor;
4663 }
4664 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4665 return GetMetadataStatic().reflection;
4666 }
4667 static const CancelBarrierRequest& default_instance();
4668
4669 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4670 static inline const CancelBarrierRequest* internal_default_instance() {
4671 return reinterpret_cast<const CancelBarrierRequest*>(
4672 &_CancelBarrierRequest_default_instance_);
4673 }
4674 static constexpr int kIndexInFileMessages =
4675 32;
4676
4677 friend void swap(CancelBarrierRequest& a, CancelBarrierRequest& b) {
4678 a.Swap(&b);
4679 }
4680 inline void Swap(CancelBarrierRequest* other) {
4681 if (other == this) return;
4682 InternalSwap(other);
4683 }
4684
4685 // implements Message ----------------------------------------------
4686
4687 inline CancelBarrierRequest* New() const final {
4688 return CreateMaybeMessage<CancelBarrierRequest>(nullptr);
4689 }
4690
4691 CancelBarrierRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4692 return CreateMaybeMessage<CancelBarrierRequest>(arena);
4693 }
4694 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4695 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4696 void CopyFrom(const CancelBarrierRequest& from);
4697 void MergeFrom(const CancelBarrierRequest& from);
4698 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4699 bool IsInitialized() const final;
4700
4701 size_t ByteSizeLong() const final;
4702 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4703 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4704 #else
4705 bool MergePartialFromCodedStream(
4706 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4707 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4708 void SerializeWithCachedSizes(
4709 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4710 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4711 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4712 int GetCachedSize() const final { return _cached_size_.Get(); }
4713
4714 private:
4715 inline void SharedCtor();
4716 inline void SharedDtor();
4717 void SetCachedSize(int size) const final;
4718 void InternalSwap(CancelBarrierRequest* other);
4719 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4720 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4721 return "tensorflow.CancelBarrierRequest";
4722 }
4723 private:
4724 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4725 return nullptr;
4726 }
4727 inline void* MaybeArenaPtr() const {
4728 return nullptr;
4729 }
4730 public:
4731
4732 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4733 private:
4734 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4735 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4736 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4737 }
4738
4739 public:
4740
4741 // nested types ----------------------------------------------------
4742
4743 // accessors -------------------------------------------------------
4744
4745 enum : int {
4746 kBarrierIdFieldNumber = 1,
4747 kSourceTaskFieldNumber = 2,
4748 };
4749 // string barrier_id = 1;
4750 void clear_barrier_id();
4751 const std::string& barrier_id() const;
4752 void set_barrier_id(const std::string& value);
4753 void set_barrier_id(std::string&& value);
4754 void set_barrier_id(const char* value);
4755 void set_barrier_id(const char* value, size_t size);
4756 std::string* mutable_barrier_id();
4757 std::string* release_barrier_id();
4758 void set_allocated_barrier_id(std::string* barrier_id);
4759
4760 // .tensorflow.CoordinatedTask source_task = 2;
4761 bool has_source_task() const;
4762 void clear_source_task();
4763 const ::tensorflow::CoordinatedTask& source_task() const;
4764 ::tensorflow::CoordinatedTask* release_source_task();
4765 ::tensorflow::CoordinatedTask* mutable_source_task();
4766 void set_allocated_source_task(::tensorflow::CoordinatedTask* source_task);
4767
4768 // @@protoc_insertion_point(class_scope:tensorflow.CancelBarrierRequest)
4769 private:
4770 class _Internal;
4771
4772 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4773 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr barrier_id_;
4774 ::tensorflow::CoordinatedTask* source_task_;
4775 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4776 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4777};
4778// -------------------------------------------------------------------
4779
4780class CancelBarrierResponse :
4781 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CancelBarrierResponse) */ {
4782 public:
4783 CancelBarrierResponse();
4784 virtual ~CancelBarrierResponse();
4785
4786 CancelBarrierResponse(const CancelBarrierResponse& from);
4787 CancelBarrierResponse(CancelBarrierResponse&& from) noexcept
4788 : CancelBarrierResponse() {
4789 *this = ::std::move(from);
4790 }
4791
4792 inline CancelBarrierResponse& operator=(const CancelBarrierResponse& from) {
4793 CopyFrom(from);
4794 return *this;
4795 }
4796 inline CancelBarrierResponse& operator=(CancelBarrierResponse&& from) noexcept {
4797 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
4798 if (this != &from) InternalSwap(&from);
4799 } else {
4800 CopyFrom(from);
4801 }
4802 return *this;
4803 }
4804
4805 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
4806 return GetDescriptor();
4807 }
4808 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
4809 return GetMetadataStatic().descriptor;
4810 }
4811 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
4812 return GetMetadataStatic().reflection;
4813 }
4814 static const CancelBarrierResponse& default_instance();
4815
4816 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
4817 static inline const CancelBarrierResponse* internal_default_instance() {
4818 return reinterpret_cast<const CancelBarrierResponse*>(
4819 &_CancelBarrierResponse_default_instance_);
4820 }
4821 static constexpr int kIndexInFileMessages =
4822 33;
4823
4824 friend void swap(CancelBarrierResponse& a, CancelBarrierResponse& b) {
4825 a.Swap(&b);
4826 }
4827 inline void Swap(CancelBarrierResponse* other) {
4828 if (other == this) return;
4829 InternalSwap(other);
4830 }
4831
4832 // implements Message ----------------------------------------------
4833
4834 inline CancelBarrierResponse* New() const final {
4835 return CreateMaybeMessage<CancelBarrierResponse>(nullptr);
4836 }
4837
4838 CancelBarrierResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4839 return CreateMaybeMessage<CancelBarrierResponse>(arena);
4840 }
4841 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4842 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
4843 void CopyFrom(const CancelBarrierResponse& from);
4844 void MergeFrom(const CancelBarrierResponse& from);
4845 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4846 bool IsInitialized() const final;
4847
4848 size_t ByteSizeLong() const final;
4849 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4850 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4851 #else
4852 bool MergePartialFromCodedStream(
4853 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
4854 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
4855 void SerializeWithCachedSizes(
4856 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
4857 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
4858 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
4859 int GetCachedSize() const final { return _cached_size_.Get(); }
4860
4861 private:
4862 inline void SharedCtor();
4863 inline void SharedDtor();
4864 void SetCachedSize(int size) const final;
4865 void InternalSwap(CancelBarrierResponse* other);
4866 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4867 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4868 return "tensorflow.CancelBarrierResponse";
4869 }
4870 private:
4871 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
4872 return nullptr;
4873 }
4874 inline void* MaybeArenaPtr() const {
4875 return nullptr;
4876 }
4877 public:
4878
4879 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
4880 private:
4881 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
4882 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto);
4883 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto.file_level_metadata[kIndexInFileMessages];
4884 }
4885
4886 public:
4887
4888 // nested types ----------------------------------------------------
4889
4890 // accessors -------------------------------------------------------
4891
4892 // @@protoc_insertion_point(class_scope:tensorflow.CancelBarrierResponse)
4893 private:
4894 class _Internal;
4895
4896 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
4897 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4898 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto;
4899};
4900// ===================================================================
4901
4902
4903// ===================================================================
4904
4905#ifdef __GNUC__
4906 #pragma GCC diagnostic push
4907 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
4908#endif // __GNUC__
4909// CoordinatedTask
4910
4911// string job_name = 1;
4912inline void CoordinatedTask::clear_job_name() {
4913 job_name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4914}
4915inline const std::string& CoordinatedTask::job_name() const {
4916 // @@protoc_insertion_point(field_get:tensorflow.CoordinatedTask.job_name)
4917 return job_name_.GetNoArena();
4918}
4919inline void CoordinatedTask::set_job_name(const std::string& value) {
4920
4921 job_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
4922 // @@protoc_insertion_point(field_set:tensorflow.CoordinatedTask.job_name)
4923}
4924inline void CoordinatedTask::set_job_name(std::string&& value) {
4925
4926 job_name_.SetNoArena(
4927 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
4928 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CoordinatedTask.job_name)
4929}
4930inline void CoordinatedTask::set_job_name(const char* value) {
4931 GOOGLE_DCHECK(value != nullptr);
4932
4933 job_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
4934 // @@protoc_insertion_point(field_set_char:tensorflow.CoordinatedTask.job_name)
4935}
4936inline void CoordinatedTask::set_job_name(const char* value, size_t size) {
4937
4938 job_name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4939 ::std::string(reinterpret_cast<const char*>(value), size));
4940 // @@protoc_insertion_point(field_set_pointer:tensorflow.CoordinatedTask.job_name)
4941}
4942inline std::string* CoordinatedTask::mutable_job_name() {
4943
4944 // @@protoc_insertion_point(field_mutable:tensorflow.CoordinatedTask.job_name)
4945 return job_name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4946}
4947inline std::string* CoordinatedTask::release_job_name() {
4948 // @@protoc_insertion_point(field_release:tensorflow.CoordinatedTask.job_name)
4949
4950 return job_name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
4951}
4952inline void CoordinatedTask::set_allocated_job_name(std::string* job_name) {
4953 if (job_name != nullptr) {
4954
4955 } else {
4956
4957 }
4958 job_name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), job_name);
4959 // @@protoc_insertion_point(field_set_allocated:tensorflow.CoordinatedTask.job_name)
4960}
4961
4962// int32 task_id = 2;
4963inline void CoordinatedTask::clear_task_id() {
4964 task_id_ = 0;
4965}
4966inline ::PROTOBUF_NAMESPACE_ID::int32 CoordinatedTask::task_id() const {
4967 // @@protoc_insertion_point(field_get:tensorflow.CoordinatedTask.task_id)
4968 return task_id_;
4969}
4970inline void CoordinatedTask::set_task_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
4971
4972 task_id_ = value;
4973 // @@protoc_insertion_point(field_set:tensorflow.CoordinatedTask.task_id)
4974}
4975
4976// -------------------------------------------------------------------
4977
4978// CoordinationServiceError
4979
4980// bool is_reported_error = 3;
4981inline void CoordinationServiceError::clear_is_reported_error() {
4982 is_reported_error_ = false;
4983}
4984inline bool CoordinationServiceError::is_reported_error() const {
4985 // @@protoc_insertion_point(field_get:tensorflow.CoordinationServiceError.is_reported_error)
4986 return is_reported_error_;
4987}
4988inline void CoordinationServiceError::set_is_reported_error(bool value) {
4989
4990 is_reported_error_ = value;
4991 // @@protoc_insertion_point(field_set:tensorflow.CoordinationServiceError.is_reported_error)
4992}
4993
4994// .tensorflow.CoordinatedTask source_task = 4;
4995inline bool CoordinationServiceError::has_source_task() const {
4996 return this != internal_default_instance() && source_task_ != nullptr;
4997}
4998inline void CoordinationServiceError::clear_source_task() {
4999 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
5000 delete source_task_;
5001 }
5002 source_task_ = nullptr;
5003}
5004inline const ::tensorflow::CoordinatedTask& CoordinationServiceError::source_task() const {
5005 const ::tensorflow::CoordinatedTask* p = source_task_;
5006 // @@protoc_insertion_point(field_get:tensorflow.CoordinationServiceError.source_task)
5007 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5008 &::tensorflow::_CoordinatedTask_default_instance_);
5009}
5010inline ::tensorflow::CoordinatedTask* CoordinationServiceError::release_source_task() {
5011 // @@protoc_insertion_point(field_release:tensorflow.CoordinationServiceError.source_task)
5012
5013 ::tensorflow::CoordinatedTask* temp = source_task_;
5014 source_task_ = nullptr;
5015 return temp;
5016}
5017inline ::tensorflow::CoordinatedTask* CoordinationServiceError::mutable_source_task() {
5018
5019 if (source_task_ == nullptr) {
5020 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5021 source_task_ = p;
5022 }
5023 // @@protoc_insertion_point(field_mutable:tensorflow.CoordinationServiceError.source_task)
5024 return source_task_;
5025}
5026inline void CoordinationServiceError::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
5027 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5028 if (message_arena == nullptr) {
5029 delete source_task_;
5030 }
5031 if (source_task) {
5032 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5033 if (message_arena != submessage_arena) {
5034 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5035 message_arena, source_task, submessage_arena);
5036 }
5037
5038 } else {
5039
5040 }
5041 source_task_ = source_task;
5042 // @@protoc_insertion_point(field_set_allocated:tensorflow.CoordinationServiceError.source_task)
5043}
5044
5045// -------------------------------------------------------------------
5046
5047// TfDeviceList
5048
5049// repeated .tensorflow.DeviceAttributes devices = 1;
5050inline int TfDeviceList::devices_size() const {
5051 return devices_.size();
5052}
5053inline ::tensorflow::DeviceAttributes* TfDeviceList::mutable_devices(int index) {
5054 // @@protoc_insertion_point(field_mutable:tensorflow.TfDeviceList.devices)
5055 return devices_.Mutable(index);
5056}
5057inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
5058TfDeviceList::mutable_devices() {
5059 // @@protoc_insertion_point(field_mutable_list:tensorflow.TfDeviceList.devices)
5060 return &devices_;
5061}
5062inline const ::tensorflow::DeviceAttributes& TfDeviceList::devices(int index) const {
5063 // @@protoc_insertion_point(field_get:tensorflow.TfDeviceList.devices)
5064 return devices_.Get(index);
5065}
5066inline ::tensorflow::DeviceAttributes* TfDeviceList::add_devices() {
5067 // @@protoc_insertion_point(field_add:tensorflow.TfDeviceList.devices)
5068 return devices_.Add();
5069}
5070inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
5071TfDeviceList::devices() const {
5072 // @@protoc_insertion_point(field_list:tensorflow.TfDeviceList.devices)
5073 return devices_;
5074}
5075
5076// -------------------------------------------------------------------
5077
5078// XlaDeviceList
5079
5080// .xla.GlobalTopologyProto devices = 1;
5081inline bool XlaDeviceList::has_devices() const {
5082 return this != internal_default_instance() && devices_ != nullptr;
5083}
5084inline const ::xla::GlobalTopologyProto& XlaDeviceList::devices() const {
5085 const ::xla::GlobalTopologyProto* p = devices_;
5086 // @@protoc_insertion_point(field_get:tensorflow.XlaDeviceList.devices)
5087 return p != nullptr ? *p : *reinterpret_cast<const ::xla::GlobalTopologyProto*>(
5088 &::xla::_GlobalTopologyProto_default_instance_);
5089}
5090inline ::xla::GlobalTopologyProto* XlaDeviceList::release_devices() {
5091 // @@protoc_insertion_point(field_release:tensorflow.XlaDeviceList.devices)
5092
5093 ::xla::GlobalTopologyProto* temp = devices_;
5094 devices_ = nullptr;
5095 return temp;
5096}
5097inline ::xla::GlobalTopologyProto* XlaDeviceList::mutable_devices() {
5098
5099 if (devices_ == nullptr) {
5100 auto* p = CreateMaybeMessage<::xla::GlobalTopologyProto>(GetArenaNoVirtual());
5101 devices_ = p;
5102 }
5103 // @@protoc_insertion_point(field_mutable:tensorflow.XlaDeviceList.devices)
5104 return devices_;
5105}
5106inline void XlaDeviceList::set_allocated_devices(::xla::GlobalTopologyProto* devices) {
5107 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5108 if (message_arena == nullptr) {
5109 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(devices_);
5110 }
5111 if (devices) {
5112 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5113 if (message_arena != submessage_arena) {
5114 devices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5115 message_arena, devices, submessage_arena);
5116 }
5117
5118 } else {
5119
5120 }
5121 devices_ = devices;
5122 // @@protoc_insertion_point(field_set_allocated:tensorflow.XlaDeviceList.devices)
5123}
5124
5125// -------------------------------------------------------------------
5126
5127// CoordinationServiceDeviceInfo
5128
5129// .tensorflow.TfDeviceList tf = 1;
5130inline bool CoordinationServiceDeviceInfo::has_tf() const {
5131 return type_case() == kTf;
5132}
5133inline void CoordinationServiceDeviceInfo::set_has_tf() {
5134 _oneof_case_[0] = kTf;
5135}
5136inline void CoordinationServiceDeviceInfo::clear_tf() {
5137 if (has_tf()) {
5138 delete type_.tf_;
5139 clear_has_type();
5140 }
5141}
5142inline ::tensorflow::TfDeviceList* CoordinationServiceDeviceInfo::release_tf() {
5143 // @@protoc_insertion_point(field_release:tensorflow.CoordinationServiceDeviceInfo.tf)
5144 if (has_tf()) {
5145 clear_has_type();
5146 ::tensorflow::TfDeviceList* temp = type_.tf_;
5147 type_.tf_ = nullptr;
5148 return temp;
5149 } else {
5150 return nullptr;
5151 }
5152}
5153inline const ::tensorflow::TfDeviceList& CoordinationServiceDeviceInfo::tf() const {
5154 // @@protoc_insertion_point(field_get:tensorflow.CoordinationServiceDeviceInfo.tf)
5155 return has_tf()
5156 ? *type_.tf_
5157 : *reinterpret_cast< ::tensorflow::TfDeviceList*>(&::tensorflow::_TfDeviceList_default_instance_);
5158}
5159inline ::tensorflow::TfDeviceList* CoordinationServiceDeviceInfo::mutable_tf() {
5160 if (!has_tf()) {
5161 clear_type();
5162 set_has_tf();
5163 type_.tf_ = CreateMaybeMessage< ::tensorflow::TfDeviceList >(
5164 GetArenaNoVirtual());
5165 }
5166 // @@protoc_insertion_point(field_mutable:tensorflow.CoordinationServiceDeviceInfo.tf)
5167 return type_.tf_;
5168}
5169
5170// .tensorflow.XlaDeviceList xla = 2;
5171inline bool CoordinationServiceDeviceInfo::has_xla() const {
5172 return type_case() == kXla;
5173}
5174inline void CoordinationServiceDeviceInfo::set_has_xla() {
5175 _oneof_case_[0] = kXla;
5176}
5177inline void CoordinationServiceDeviceInfo::clear_xla() {
5178 if (has_xla()) {
5179 delete type_.xla_;
5180 clear_has_type();
5181 }
5182}
5183inline ::tensorflow::XlaDeviceList* CoordinationServiceDeviceInfo::release_xla() {
5184 // @@protoc_insertion_point(field_release:tensorflow.CoordinationServiceDeviceInfo.xla)
5185 if (has_xla()) {
5186 clear_has_type();
5187 ::tensorflow::XlaDeviceList* temp = type_.xla_;
5188 type_.xla_ = nullptr;
5189 return temp;
5190 } else {
5191 return nullptr;
5192 }
5193}
5194inline const ::tensorflow::XlaDeviceList& CoordinationServiceDeviceInfo::xla() const {
5195 // @@protoc_insertion_point(field_get:tensorflow.CoordinationServiceDeviceInfo.xla)
5196 return has_xla()
5197 ? *type_.xla_
5198 : *reinterpret_cast< ::tensorflow::XlaDeviceList*>(&::tensorflow::_XlaDeviceList_default_instance_);
5199}
5200inline ::tensorflow::XlaDeviceList* CoordinationServiceDeviceInfo::mutable_xla() {
5201 if (!has_xla()) {
5202 clear_type();
5203 set_has_xla();
5204 type_.xla_ = CreateMaybeMessage< ::tensorflow::XlaDeviceList >(
5205 GetArenaNoVirtual());
5206 }
5207 // @@protoc_insertion_point(field_mutable:tensorflow.CoordinationServiceDeviceInfo.xla)
5208 return type_.xla_;
5209}
5210
5211inline bool CoordinationServiceDeviceInfo::has_type() const {
5212 return type_case() != TYPE_NOT_SET;
5213}
5214inline void CoordinationServiceDeviceInfo::clear_has_type() {
5215 _oneof_case_[0] = TYPE_NOT_SET;
5216}
5217inline CoordinationServiceDeviceInfo::TypeCase CoordinationServiceDeviceInfo::type_case() const {
5218 return CoordinationServiceDeviceInfo::TypeCase(_oneof_case_[0]);
5219}
5220// -------------------------------------------------------------------
5221
5222// RegisterTaskRequest
5223
5224// fixed64 incarnation = 3;
5225inline void RegisterTaskRequest::clear_incarnation() {
5226 incarnation_ = PROTOBUF_ULONGLONG(0);
5227}
5228inline ::PROTOBUF_NAMESPACE_ID::uint64 RegisterTaskRequest::incarnation() const {
5229 // @@protoc_insertion_point(field_get:tensorflow.RegisterTaskRequest.incarnation)
5230 return incarnation_;
5231}
5232inline void RegisterTaskRequest::set_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value) {
5233
5234 incarnation_ = value;
5235 // @@protoc_insertion_point(field_set:tensorflow.RegisterTaskRequest.incarnation)
5236}
5237
5238// .tensorflow.CoordinatedTask source_task = 5;
5239inline bool RegisterTaskRequest::has_source_task() const {
5240 return this != internal_default_instance() && source_task_ != nullptr;
5241}
5242inline void RegisterTaskRequest::clear_source_task() {
5243 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
5244 delete source_task_;
5245 }
5246 source_task_ = nullptr;
5247}
5248inline const ::tensorflow::CoordinatedTask& RegisterTaskRequest::source_task() const {
5249 const ::tensorflow::CoordinatedTask* p = source_task_;
5250 // @@protoc_insertion_point(field_get:tensorflow.RegisterTaskRequest.source_task)
5251 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5252 &::tensorflow::_CoordinatedTask_default_instance_);
5253}
5254inline ::tensorflow::CoordinatedTask* RegisterTaskRequest::release_source_task() {
5255 // @@protoc_insertion_point(field_release:tensorflow.RegisterTaskRequest.source_task)
5256
5257 ::tensorflow::CoordinatedTask* temp = source_task_;
5258 source_task_ = nullptr;
5259 return temp;
5260}
5261inline ::tensorflow::CoordinatedTask* RegisterTaskRequest::mutable_source_task() {
5262
5263 if (source_task_ == nullptr) {
5264 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5265 source_task_ = p;
5266 }
5267 // @@protoc_insertion_point(field_mutable:tensorflow.RegisterTaskRequest.source_task)
5268 return source_task_;
5269}
5270inline void RegisterTaskRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
5271 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5272 if (message_arena == nullptr) {
5273 delete source_task_;
5274 }
5275 if (source_task) {
5276 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5277 if (message_arena != submessage_arena) {
5278 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5279 message_arena, source_task, submessage_arena);
5280 }
5281
5282 } else {
5283
5284 }
5285 source_task_ = source_task;
5286 // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterTaskRequest.source_task)
5287}
5288
5289// -------------------------------------------------------------------
5290
5291// RegisterTaskResponse
5292
5293// fixed64 leader_incarnation = 1;
5294inline void RegisterTaskResponse::clear_leader_incarnation() {
5295 leader_incarnation_ = PROTOBUF_ULONGLONG(0);
5296}
5297inline ::PROTOBUF_NAMESPACE_ID::uint64 RegisterTaskResponse::leader_incarnation() const {
5298 // @@protoc_insertion_point(field_get:tensorflow.RegisterTaskResponse.leader_incarnation)
5299 return leader_incarnation_;
5300}
5301inline void RegisterTaskResponse::set_leader_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value) {
5302
5303 leader_incarnation_ = value;
5304 // @@protoc_insertion_point(field_set:tensorflow.RegisterTaskResponse.leader_incarnation)
5305}
5306
5307// -------------------------------------------------------------------
5308
5309// HeartbeatRequest
5310
5311// fixed64 incarnation = 3;
5312inline void HeartbeatRequest::clear_incarnation() {
5313 incarnation_ = PROTOBUF_ULONGLONG(0);
5314}
5315inline ::PROTOBUF_NAMESPACE_ID::uint64 HeartbeatRequest::incarnation() const {
5316 // @@protoc_insertion_point(field_get:tensorflow.HeartbeatRequest.incarnation)
5317 return incarnation_;
5318}
5319inline void HeartbeatRequest::set_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value) {
5320
5321 incarnation_ = value;
5322 // @@protoc_insertion_point(field_set:tensorflow.HeartbeatRequest.incarnation)
5323}
5324
5325// .tensorflow.CoordinatedTask source_task = 4;
5326inline bool HeartbeatRequest::has_source_task() const {
5327 return this != internal_default_instance() && source_task_ != nullptr;
5328}
5329inline void HeartbeatRequest::clear_source_task() {
5330 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
5331 delete source_task_;
5332 }
5333 source_task_ = nullptr;
5334}
5335inline const ::tensorflow::CoordinatedTask& HeartbeatRequest::source_task() const {
5336 const ::tensorflow::CoordinatedTask* p = source_task_;
5337 // @@protoc_insertion_point(field_get:tensorflow.HeartbeatRequest.source_task)
5338 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5339 &::tensorflow::_CoordinatedTask_default_instance_);
5340}
5341inline ::tensorflow::CoordinatedTask* HeartbeatRequest::release_source_task() {
5342 // @@protoc_insertion_point(field_release:tensorflow.HeartbeatRequest.source_task)
5343
5344 ::tensorflow::CoordinatedTask* temp = source_task_;
5345 source_task_ = nullptr;
5346 return temp;
5347}
5348inline ::tensorflow::CoordinatedTask* HeartbeatRequest::mutable_source_task() {
5349
5350 if (source_task_ == nullptr) {
5351 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5352 source_task_ = p;
5353 }
5354 // @@protoc_insertion_point(field_mutable:tensorflow.HeartbeatRequest.source_task)
5355 return source_task_;
5356}
5357inline void HeartbeatRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
5358 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5359 if (message_arena == nullptr) {
5360 delete source_task_;
5361 }
5362 if (source_task) {
5363 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5364 if (message_arena != submessage_arena) {
5365 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5366 message_arena, source_task, submessage_arena);
5367 }
5368
5369 } else {
5370
5371 }
5372 source_task_ = source_task;
5373 // @@protoc_insertion_point(field_set_allocated:tensorflow.HeartbeatRequest.source_task)
5374}
5375
5376// -------------------------------------------------------------------
5377
5378// HeartbeatResponse
5379
5380// fixed64 leader_incarnation = 1;
5381inline void HeartbeatResponse::clear_leader_incarnation() {
5382 leader_incarnation_ = PROTOBUF_ULONGLONG(0);
5383}
5384inline ::PROTOBUF_NAMESPACE_ID::uint64 HeartbeatResponse::leader_incarnation() const {
5385 // @@protoc_insertion_point(field_get:tensorflow.HeartbeatResponse.leader_incarnation)
5386 return leader_incarnation_;
5387}
5388inline void HeartbeatResponse::set_leader_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value) {
5389
5390 leader_incarnation_ = value;
5391 // @@protoc_insertion_point(field_set:tensorflow.HeartbeatResponse.leader_incarnation)
5392}
5393
5394// -------------------------------------------------------------------
5395
5396// WaitForAllTasksRequest
5397
5398// .tensorflow.CoordinationServiceDeviceInfo local_device_info = 4;
5399inline bool WaitForAllTasksRequest::has_local_device_info() const {
5400 return this != internal_default_instance() && local_device_info_ != nullptr;
5401}
5402inline void WaitForAllTasksRequest::clear_local_device_info() {
5403 if (GetArenaNoVirtual() == nullptr && local_device_info_ != nullptr) {
5404 delete local_device_info_;
5405 }
5406 local_device_info_ = nullptr;
5407}
5408inline const ::tensorflow::CoordinationServiceDeviceInfo& WaitForAllTasksRequest::local_device_info() const {
5409 const ::tensorflow::CoordinationServiceDeviceInfo* p = local_device_info_;
5410 // @@protoc_insertion_point(field_get:tensorflow.WaitForAllTasksRequest.local_device_info)
5411 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinationServiceDeviceInfo*>(
5412 &::tensorflow::_CoordinationServiceDeviceInfo_default_instance_);
5413}
5414inline ::tensorflow::CoordinationServiceDeviceInfo* WaitForAllTasksRequest::release_local_device_info() {
5415 // @@protoc_insertion_point(field_release:tensorflow.WaitForAllTasksRequest.local_device_info)
5416
5417 ::tensorflow::CoordinationServiceDeviceInfo* temp = local_device_info_;
5418 local_device_info_ = nullptr;
5419 return temp;
5420}
5421inline ::tensorflow::CoordinationServiceDeviceInfo* WaitForAllTasksRequest::mutable_local_device_info() {
5422
5423 if (local_device_info_ == nullptr) {
5424 auto* p = CreateMaybeMessage<::tensorflow::CoordinationServiceDeviceInfo>(GetArenaNoVirtual());
5425 local_device_info_ = p;
5426 }
5427 // @@protoc_insertion_point(field_mutable:tensorflow.WaitForAllTasksRequest.local_device_info)
5428 return local_device_info_;
5429}
5430inline void WaitForAllTasksRequest::set_allocated_local_device_info(::tensorflow::CoordinationServiceDeviceInfo* local_device_info) {
5431 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5432 if (message_arena == nullptr) {
5433 delete local_device_info_;
5434 }
5435 if (local_device_info) {
5436 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5437 if (message_arena != submessage_arena) {
5438 local_device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5439 message_arena, local_device_info, submessage_arena);
5440 }
5441
5442 } else {
5443
5444 }
5445 local_device_info_ = local_device_info;
5446 // @@protoc_insertion_point(field_set_allocated:tensorflow.WaitForAllTasksRequest.local_device_info)
5447}
5448
5449// .tensorflow.CoordinatedTask source_task = 5;
5450inline bool WaitForAllTasksRequest::has_source_task() const {
5451 return this != internal_default_instance() && source_task_ != nullptr;
5452}
5453inline void WaitForAllTasksRequest::clear_source_task() {
5454 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
5455 delete source_task_;
5456 }
5457 source_task_ = nullptr;
5458}
5459inline const ::tensorflow::CoordinatedTask& WaitForAllTasksRequest::source_task() const {
5460 const ::tensorflow::CoordinatedTask* p = source_task_;
5461 // @@protoc_insertion_point(field_get:tensorflow.WaitForAllTasksRequest.source_task)
5462 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5463 &::tensorflow::_CoordinatedTask_default_instance_);
5464}
5465inline ::tensorflow::CoordinatedTask* WaitForAllTasksRequest::release_source_task() {
5466 // @@protoc_insertion_point(field_release:tensorflow.WaitForAllTasksRequest.source_task)
5467
5468 ::tensorflow::CoordinatedTask* temp = source_task_;
5469 source_task_ = nullptr;
5470 return temp;
5471}
5472inline ::tensorflow::CoordinatedTask* WaitForAllTasksRequest::mutable_source_task() {
5473
5474 if (source_task_ == nullptr) {
5475 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5476 source_task_ = p;
5477 }
5478 // @@protoc_insertion_point(field_mutable:tensorflow.WaitForAllTasksRequest.source_task)
5479 return source_task_;
5480}
5481inline void WaitForAllTasksRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
5482 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5483 if (message_arena == nullptr) {
5484 delete source_task_;
5485 }
5486 if (source_task) {
5487 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5488 if (message_arena != submessage_arena) {
5489 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5490 message_arena, source_task, submessage_arena);
5491 }
5492
5493 } else {
5494
5495 }
5496 source_task_ = source_task;
5497 // @@protoc_insertion_point(field_set_allocated:tensorflow.WaitForAllTasksRequest.source_task)
5498}
5499
5500// -------------------------------------------------------------------
5501
5502// WaitForAllTasksResponse
5503
5504// fixed64 leader_incarnation = 1;
5505inline void WaitForAllTasksResponse::clear_leader_incarnation() {
5506 leader_incarnation_ = PROTOBUF_ULONGLONG(0);
5507}
5508inline ::PROTOBUF_NAMESPACE_ID::uint64 WaitForAllTasksResponse::leader_incarnation() const {
5509 // @@protoc_insertion_point(field_get:tensorflow.WaitForAllTasksResponse.leader_incarnation)
5510 return leader_incarnation_;
5511}
5512inline void WaitForAllTasksResponse::set_leader_incarnation(::PROTOBUF_NAMESPACE_ID::uint64 value) {
5513
5514 leader_incarnation_ = value;
5515 // @@protoc_insertion_point(field_set:tensorflow.WaitForAllTasksResponse.leader_incarnation)
5516}
5517
5518// .tensorflow.CoordinationServiceDeviceInfo cluster_device_info = 3;
5519inline bool WaitForAllTasksResponse::has_cluster_device_info() const {
5520 return this != internal_default_instance() && cluster_device_info_ != nullptr;
5521}
5522inline void WaitForAllTasksResponse::clear_cluster_device_info() {
5523 if (GetArenaNoVirtual() == nullptr && cluster_device_info_ != nullptr) {
5524 delete cluster_device_info_;
5525 }
5526 cluster_device_info_ = nullptr;
5527}
5528inline const ::tensorflow::CoordinationServiceDeviceInfo& WaitForAllTasksResponse::cluster_device_info() const {
5529 const ::tensorflow::CoordinationServiceDeviceInfo* p = cluster_device_info_;
5530 // @@protoc_insertion_point(field_get:tensorflow.WaitForAllTasksResponse.cluster_device_info)
5531 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinationServiceDeviceInfo*>(
5532 &::tensorflow::_CoordinationServiceDeviceInfo_default_instance_);
5533}
5534inline ::tensorflow::CoordinationServiceDeviceInfo* WaitForAllTasksResponse::release_cluster_device_info() {
5535 // @@protoc_insertion_point(field_release:tensorflow.WaitForAllTasksResponse.cluster_device_info)
5536
5537 ::tensorflow::CoordinationServiceDeviceInfo* temp = cluster_device_info_;
5538 cluster_device_info_ = nullptr;
5539 return temp;
5540}
5541inline ::tensorflow::CoordinationServiceDeviceInfo* WaitForAllTasksResponse::mutable_cluster_device_info() {
5542
5543 if (cluster_device_info_ == nullptr) {
5544 auto* p = CreateMaybeMessage<::tensorflow::CoordinationServiceDeviceInfo>(GetArenaNoVirtual());
5545 cluster_device_info_ = p;
5546 }
5547 // @@protoc_insertion_point(field_mutable:tensorflow.WaitForAllTasksResponse.cluster_device_info)
5548 return cluster_device_info_;
5549}
5550inline void WaitForAllTasksResponse::set_allocated_cluster_device_info(::tensorflow::CoordinationServiceDeviceInfo* cluster_device_info) {
5551 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5552 if (message_arena == nullptr) {
5553 delete cluster_device_info_;
5554 }
5555 if (cluster_device_info) {
5556 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5557 if (message_arena != submessage_arena) {
5558 cluster_device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5559 message_arena, cluster_device_info, submessage_arena);
5560 }
5561
5562 } else {
5563
5564 }
5565 cluster_device_info_ = cluster_device_info;
5566 // @@protoc_insertion_point(field_set_allocated:tensorflow.WaitForAllTasksResponse.cluster_device_info)
5567}
5568
5569// -------------------------------------------------------------------
5570
5571// ShutdownTaskRequest
5572
5573// .tensorflow.CoordinatedTask source_task = 1;
5574inline bool ShutdownTaskRequest::has_source_task() const {
5575 return this != internal_default_instance() && source_task_ != nullptr;
5576}
5577inline void ShutdownTaskRequest::clear_source_task() {
5578 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
5579 delete source_task_;
5580 }
5581 source_task_ = nullptr;
5582}
5583inline const ::tensorflow::CoordinatedTask& ShutdownTaskRequest::source_task() const {
5584 const ::tensorflow::CoordinatedTask* p = source_task_;
5585 // @@protoc_insertion_point(field_get:tensorflow.ShutdownTaskRequest.source_task)
5586 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5587 &::tensorflow::_CoordinatedTask_default_instance_);
5588}
5589inline ::tensorflow::CoordinatedTask* ShutdownTaskRequest::release_source_task() {
5590 // @@protoc_insertion_point(field_release:tensorflow.ShutdownTaskRequest.source_task)
5591
5592 ::tensorflow::CoordinatedTask* temp = source_task_;
5593 source_task_ = nullptr;
5594 return temp;
5595}
5596inline ::tensorflow::CoordinatedTask* ShutdownTaskRequest::mutable_source_task() {
5597
5598 if (source_task_ == nullptr) {
5599 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5600 source_task_ = p;
5601 }
5602 // @@protoc_insertion_point(field_mutable:tensorflow.ShutdownTaskRequest.source_task)
5603 return source_task_;
5604}
5605inline void ShutdownTaskRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
5606 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5607 if (message_arena == nullptr) {
5608 delete source_task_;
5609 }
5610 if (source_task) {
5611 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5612 if (message_arena != submessage_arena) {
5613 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5614 message_arena, source_task, submessage_arena);
5615 }
5616
5617 } else {
5618
5619 }
5620 source_task_ = source_task;
5621 // @@protoc_insertion_point(field_set_allocated:tensorflow.ShutdownTaskRequest.source_task)
5622}
5623
5624// -------------------------------------------------------------------
5625
5626// ShutdownTaskResponse
5627
5628// -------------------------------------------------------------------
5629
5630// ResetTaskRequest
5631
5632// .tensorflow.CoordinatedTask source_task = 1;
5633inline bool ResetTaskRequest::has_source_task() const {
5634 return this != internal_default_instance() && source_task_ != nullptr;
5635}
5636inline void ResetTaskRequest::clear_source_task() {
5637 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
5638 delete source_task_;
5639 }
5640 source_task_ = nullptr;
5641}
5642inline const ::tensorflow::CoordinatedTask& ResetTaskRequest::source_task() const {
5643 const ::tensorflow::CoordinatedTask* p = source_task_;
5644 // @@protoc_insertion_point(field_get:tensorflow.ResetTaskRequest.source_task)
5645 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5646 &::tensorflow::_CoordinatedTask_default_instance_);
5647}
5648inline ::tensorflow::CoordinatedTask* ResetTaskRequest::release_source_task() {
5649 // @@protoc_insertion_point(field_release:tensorflow.ResetTaskRequest.source_task)
5650
5651 ::tensorflow::CoordinatedTask* temp = source_task_;
5652 source_task_ = nullptr;
5653 return temp;
5654}
5655inline ::tensorflow::CoordinatedTask* ResetTaskRequest::mutable_source_task() {
5656
5657 if (source_task_ == nullptr) {
5658 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5659 source_task_ = p;
5660 }
5661 // @@protoc_insertion_point(field_mutable:tensorflow.ResetTaskRequest.source_task)
5662 return source_task_;
5663}
5664inline void ResetTaskRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
5665 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5666 if (message_arena == nullptr) {
5667 delete source_task_;
5668 }
5669 if (source_task) {
5670 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5671 if (message_arena != submessage_arena) {
5672 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5673 message_arena, source_task, submessage_arena);
5674 }
5675
5676 } else {
5677
5678 }
5679 source_task_ = source_task;
5680 // @@protoc_insertion_point(field_set_allocated:tensorflow.ResetTaskRequest.source_task)
5681}
5682
5683// -------------------------------------------------------------------
5684
5685// ResetTaskResponse
5686
5687// -------------------------------------------------------------------
5688
5689// ReportErrorToTaskRequest
5690
5691// int32 error_code = 1;
5692inline void ReportErrorToTaskRequest::clear_error_code() {
5693 error_code_ = 0;
5694}
5695inline ::PROTOBUF_NAMESPACE_ID::int32 ReportErrorToTaskRequest::error_code() const {
5696 // @@protoc_insertion_point(field_get:tensorflow.ReportErrorToTaskRequest.error_code)
5697 return error_code_;
5698}
5699inline void ReportErrorToTaskRequest::set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value) {
5700
5701 error_code_ = value;
5702 // @@protoc_insertion_point(field_set:tensorflow.ReportErrorToTaskRequest.error_code)
5703}
5704
5705// string error_message = 2;
5706inline void ReportErrorToTaskRequest::clear_error_message() {
5707 error_message_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5708}
5709inline const std::string& ReportErrorToTaskRequest::error_message() const {
5710 // @@protoc_insertion_point(field_get:tensorflow.ReportErrorToTaskRequest.error_message)
5711 return error_message_.GetNoArena();
5712}
5713inline void ReportErrorToTaskRequest::set_error_message(const std::string& value) {
5714
5715 error_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
5716 // @@protoc_insertion_point(field_set:tensorflow.ReportErrorToTaskRequest.error_message)
5717}
5718inline void ReportErrorToTaskRequest::set_error_message(std::string&& value) {
5719
5720 error_message_.SetNoArena(
5721 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5722 // @@protoc_insertion_point(field_set_rvalue:tensorflow.ReportErrorToTaskRequest.error_message)
5723}
5724inline void ReportErrorToTaskRequest::set_error_message(const char* value) {
5725 GOOGLE_DCHECK(value != nullptr);
5726
5727 error_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5728 // @@protoc_insertion_point(field_set_char:tensorflow.ReportErrorToTaskRequest.error_message)
5729}
5730inline void ReportErrorToTaskRequest::set_error_message(const char* value, size_t size) {
5731
5732 error_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5733 ::std::string(reinterpret_cast<const char*>(value), size));
5734 // @@protoc_insertion_point(field_set_pointer:tensorflow.ReportErrorToTaskRequest.error_message)
5735}
5736inline std::string* ReportErrorToTaskRequest::mutable_error_message() {
5737
5738 // @@protoc_insertion_point(field_mutable:tensorflow.ReportErrorToTaskRequest.error_message)
5739 return error_message_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5740}
5741inline std::string* ReportErrorToTaskRequest::release_error_message() {
5742 // @@protoc_insertion_point(field_release:tensorflow.ReportErrorToTaskRequest.error_message)
5743
5744 return error_message_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5745}
5746inline void ReportErrorToTaskRequest::set_allocated_error_message(std::string* error_message) {
5747 if (error_message != nullptr) {
5748
5749 } else {
5750
5751 }
5752 error_message_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), error_message);
5753 // @@protoc_insertion_point(field_set_allocated:tensorflow.ReportErrorToTaskRequest.error_message)
5754}
5755
5756// .tensorflow.CoordinationServiceError error_payload = 5;
5757inline bool ReportErrorToTaskRequest::has_error_payload() const {
5758 return this != internal_default_instance() && error_payload_ != nullptr;
5759}
5760inline void ReportErrorToTaskRequest::clear_error_payload() {
5761 if (GetArenaNoVirtual() == nullptr && error_payload_ != nullptr) {
5762 delete error_payload_;
5763 }
5764 error_payload_ = nullptr;
5765}
5766inline const ::tensorflow::CoordinationServiceError& ReportErrorToTaskRequest::error_payload() const {
5767 const ::tensorflow::CoordinationServiceError* p = error_payload_;
5768 // @@protoc_insertion_point(field_get:tensorflow.ReportErrorToTaskRequest.error_payload)
5769 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinationServiceError*>(
5770 &::tensorflow::_CoordinationServiceError_default_instance_);
5771}
5772inline ::tensorflow::CoordinationServiceError* ReportErrorToTaskRequest::release_error_payload() {
5773 // @@protoc_insertion_point(field_release:tensorflow.ReportErrorToTaskRequest.error_payload)
5774
5775 ::tensorflow::CoordinationServiceError* temp = error_payload_;
5776 error_payload_ = nullptr;
5777 return temp;
5778}
5779inline ::tensorflow::CoordinationServiceError* ReportErrorToTaskRequest::mutable_error_payload() {
5780
5781 if (error_payload_ == nullptr) {
5782 auto* p = CreateMaybeMessage<::tensorflow::CoordinationServiceError>(GetArenaNoVirtual());
5783 error_payload_ = p;
5784 }
5785 // @@protoc_insertion_point(field_mutable:tensorflow.ReportErrorToTaskRequest.error_payload)
5786 return error_payload_;
5787}
5788inline void ReportErrorToTaskRequest::set_allocated_error_payload(::tensorflow::CoordinationServiceError* error_payload) {
5789 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5790 if (message_arena == nullptr) {
5791 delete error_payload_;
5792 }
5793 if (error_payload) {
5794 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5795 if (message_arena != submessage_arena) {
5796 error_payload = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5797 message_arena, error_payload, submessage_arena);
5798 }
5799
5800 } else {
5801
5802 }
5803 error_payload_ = error_payload;
5804 // @@protoc_insertion_point(field_set_allocated:tensorflow.ReportErrorToTaskRequest.error_payload)
5805}
5806
5807// -------------------------------------------------------------------
5808
5809// ReportErrorToTaskResponse
5810
5811// -------------------------------------------------------------------
5812
5813// ReportErrorToServiceRequest
5814
5815// int32 error_code = 1;
5816inline void ReportErrorToServiceRequest::clear_error_code() {
5817 error_code_ = 0;
5818}
5819inline ::PROTOBUF_NAMESPACE_ID::int32 ReportErrorToServiceRequest::error_code() const {
5820 // @@protoc_insertion_point(field_get:tensorflow.ReportErrorToServiceRequest.error_code)
5821 return error_code_;
5822}
5823inline void ReportErrorToServiceRequest::set_error_code(::PROTOBUF_NAMESPACE_ID::int32 value) {
5824
5825 error_code_ = value;
5826 // @@protoc_insertion_point(field_set:tensorflow.ReportErrorToServiceRequest.error_code)
5827}
5828
5829// string error_message = 2;
5830inline void ReportErrorToServiceRequest::clear_error_message() {
5831 error_message_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5832}
5833inline const std::string& ReportErrorToServiceRequest::error_message() const {
5834 // @@protoc_insertion_point(field_get:tensorflow.ReportErrorToServiceRequest.error_message)
5835 return error_message_.GetNoArena();
5836}
5837inline void ReportErrorToServiceRequest::set_error_message(const std::string& value) {
5838
5839 error_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
5840 // @@protoc_insertion_point(field_set:tensorflow.ReportErrorToServiceRequest.error_message)
5841}
5842inline void ReportErrorToServiceRequest::set_error_message(std::string&& value) {
5843
5844 error_message_.SetNoArena(
5845 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5846 // @@protoc_insertion_point(field_set_rvalue:tensorflow.ReportErrorToServiceRequest.error_message)
5847}
5848inline void ReportErrorToServiceRequest::set_error_message(const char* value) {
5849 GOOGLE_DCHECK(value != nullptr);
5850
5851 error_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5852 // @@protoc_insertion_point(field_set_char:tensorflow.ReportErrorToServiceRequest.error_message)
5853}
5854inline void ReportErrorToServiceRequest::set_error_message(const char* value, size_t size) {
5855
5856 error_message_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5857 ::std::string(reinterpret_cast<const char*>(value), size));
5858 // @@protoc_insertion_point(field_set_pointer:tensorflow.ReportErrorToServiceRequest.error_message)
5859}
5860inline std::string* ReportErrorToServiceRequest::mutable_error_message() {
5861
5862 // @@protoc_insertion_point(field_mutable:tensorflow.ReportErrorToServiceRequest.error_message)
5863 return error_message_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5864}
5865inline std::string* ReportErrorToServiceRequest::release_error_message() {
5866 // @@protoc_insertion_point(field_release:tensorflow.ReportErrorToServiceRequest.error_message)
5867
5868 return error_message_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5869}
5870inline void ReportErrorToServiceRequest::set_allocated_error_message(std::string* error_message) {
5871 if (error_message != nullptr) {
5872
5873 } else {
5874
5875 }
5876 error_message_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), error_message);
5877 // @@protoc_insertion_point(field_set_allocated:tensorflow.ReportErrorToServiceRequest.error_message)
5878}
5879
5880// .tensorflow.CoordinatedTask error_origin = 5;
5881inline bool ReportErrorToServiceRequest::has_error_origin() const {
5882 return this != internal_default_instance() && error_origin_ != nullptr;
5883}
5884inline void ReportErrorToServiceRequest::clear_error_origin() {
5885 if (GetArenaNoVirtual() == nullptr && error_origin_ != nullptr) {
5886 delete error_origin_;
5887 }
5888 error_origin_ = nullptr;
5889}
5890inline const ::tensorflow::CoordinatedTask& ReportErrorToServiceRequest::error_origin() const {
5891 const ::tensorflow::CoordinatedTask* p = error_origin_;
5892 // @@protoc_insertion_point(field_get:tensorflow.ReportErrorToServiceRequest.error_origin)
5893 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
5894 &::tensorflow::_CoordinatedTask_default_instance_);
5895}
5896inline ::tensorflow::CoordinatedTask* ReportErrorToServiceRequest::release_error_origin() {
5897 // @@protoc_insertion_point(field_release:tensorflow.ReportErrorToServiceRequest.error_origin)
5898
5899 ::tensorflow::CoordinatedTask* temp = error_origin_;
5900 error_origin_ = nullptr;
5901 return temp;
5902}
5903inline ::tensorflow::CoordinatedTask* ReportErrorToServiceRequest::mutable_error_origin() {
5904
5905 if (error_origin_ == nullptr) {
5906 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
5907 error_origin_ = p;
5908 }
5909 // @@protoc_insertion_point(field_mutable:tensorflow.ReportErrorToServiceRequest.error_origin)
5910 return error_origin_;
5911}
5912inline void ReportErrorToServiceRequest::set_allocated_error_origin(::tensorflow::CoordinatedTask* error_origin) {
5913 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5914 if (message_arena == nullptr) {
5915 delete error_origin_;
5916 }
5917 if (error_origin) {
5918 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
5919 if (message_arena != submessage_arena) {
5920 error_origin = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5921 message_arena, error_origin, submessage_arena);
5922 }
5923
5924 } else {
5925
5926 }
5927 error_origin_ = error_origin;
5928 // @@protoc_insertion_point(field_set_allocated:tensorflow.ReportErrorToServiceRequest.error_origin)
5929}
5930
5931// -------------------------------------------------------------------
5932
5933// ReportErrorToServiceResponse
5934
5935// -------------------------------------------------------------------
5936
5937// KeyValueEntry
5938
5939// string key = 1;
5940inline void KeyValueEntry::clear_key() {
5941 key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5942}
5943inline const std::string& KeyValueEntry::key() const {
5944 // @@protoc_insertion_point(field_get:tensorflow.KeyValueEntry.key)
5945 return key_.GetNoArena();
5946}
5947inline void KeyValueEntry::set_key(const std::string& value) {
5948
5949 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
5950 // @@protoc_insertion_point(field_set:tensorflow.KeyValueEntry.key)
5951}
5952inline void KeyValueEntry::set_key(std::string&& value) {
5953
5954 key_.SetNoArena(
5955 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
5956 // @@protoc_insertion_point(field_set_rvalue:tensorflow.KeyValueEntry.key)
5957}
5958inline void KeyValueEntry::set_key(const char* value) {
5959 GOOGLE_DCHECK(value != nullptr);
5960
5961 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
5962 // @@protoc_insertion_point(field_set_char:tensorflow.KeyValueEntry.key)
5963}
5964inline void KeyValueEntry::set_key(const char* value, size_t size) {
5965
5966 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5967 ::std::string(reinterpret_cast<const char*>(value), size));
5968 // @@protoc_insertion_point(field_set_pointer:tensorflow.KeyValueEntry.key)
5969}
5970inline std::string* KeyValueEntry::mutable_key() {
5971
5972 // @@protoc_insertion_point(field_mutable:tensorflow.KeyValueEntry.key)
5973 return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5974}
5975inline std::string* KeyValueEntry::release_key() {
5976 // @@protoc_insertion_point(field_release:tensorflow.KeyValueEntry.key)
5977
5978 return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5979}
5980inline void KeyValueEntry::set_allocated_key(std::string* key) {
5981 if (key != nullptr) {
5982
5983 } else {
5984
5985 }
5986 key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
5987 // @@protoc_insertion_point(field_set_allocated:tensorflow.KeyValueEntry.key)
5988}
5989
5990// bytes value = 2;
5991inline void KeyValueEntry::clear_value() {
5992 value_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
5993}
5994inline const std::string& KeyValueEntry::value() const {
5995 // @@protoc_insertion_point(field_get:tensorflow.KeyValueEntry.value)
5996 return value_.GetNoArena();
5997}
5998inline void KeyValueEntry::set_value(const std::string& value) {
5999
6000 value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6001 // @@protoc_insertion_point(field_set:tensorflow.KeyValueEntry.value)
6002}
6003inline void KeyValueEntry::set_value(std::string&& value) {
6004
6005 value_.SetNoArena(
6006 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6007 // @@protoc_insertion_point(field_set_rvalue:tensorflow.KeyValueEntry.value)
6008}
6009inline void KeyValueEntry::set_value(const char* value) {
6010 GOOGLE_DCHECK(value != nullptr);
6011
6012 value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6013 // @@protoc_insertion_point(field_set_char:tensorflow.KeyValueEntry.value)
6014}
6015inline void KeyValueEntry::set_value(const void* value, size_t size) {
6016
6017 value_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6018 ::std::string(reinterpret_cast<const char*>(value), size));
6019 // @@protoc_insertion_point(field_set_pointer:tensorflow.KeyValueEntry.value)
6020}
6021inline std::string* KeyValueEntry::mutable_value() {
6022
6023 // @@protoc_insertion_point(field_mutable:tensorflow.KeyValueEntry.value)
6024 return value_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6025}
6026inline std::string* KeyValueEntry::release_value() {
6027 // @@protoc_insertion_point(field_release:tensorflow.KeyValueEntry.value)
6028
6029 return value_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6030}
6031inline void KeyValueEntry::set_allocated_value(std::string* value) {
6032 if (value != nullptr) {
6033
6034 } else {
6035
6036 }
6037 value_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6038 // @@protoc_insertion_point(field_set_allocated:tensorflow.KeyValueEntry.value)
6039}
6040
6041// -------------------------------------------------------------------
6042
6043// InsertKeyValueRequest
6044
6045// .tensorflow.KeyValueEntry kv = 1;
6046inline bool InsertKeyValueRequest::has_kv() const {
6047 return this != internal_default_instance() && kv_ != nullptr;
6048}
6049inline void InsertKeyValueRequest::clear_kv() {
6050 if (GetArenaNoVirtual() == nullptr && kv_ != nullptr) {
6051 delete kv_;
6052 }
6053 kv_ = nullptr;
6054}
6055inline const ::tensorflow::KeyValueEntry& InsertKeyValueRequest::kv() const {
6056 const ::tensorflow::KeyValueEntry* p = kv_;
6057 // @@protoc_insertion_point(field_get:tensorflow.InsertKeyValueRequest.kv)
6058 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::KeyValueEntry*>(
6059 &::tensorflow::_KeyValueEntry_default_instance_);
6060}
6061inline ::tensorflow::KeyValueEntry* InsertKeyValueRequest::release_kv() {
6062 // @@protoc_insertion_point(field_release:tensorflow.InsertKeyValueRequest.kv)
6063
6064 ::tensorflow::KeyValueEntry* temp = kv_;
6065 kv_ = nullptr;
6066 return temp;
6067}
6068inline ::tensorflow::KeyValueEntry* InsertKeyValueRequest::mutable_kv() {
6069
6070 if (kv_ == nullptr) {
6071 auto* p = CreateMaybeMessage<::tensorflow::KeyValueEntry>(GetArenaNoVirtual());
6072 kv_ = p;
6073 }
6074 // @@protoc_insertion_point(field_mutable:tensorflow.InsertKeyValueRequest.kv)
6075 return kv_;
6076}
6077inline void InsertKeyValueRequest::set_allocated_kv(::tensorflow::KeyValueEntry* kv) {
6078 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6079 if (message_arena == nullptr) {
6080 delete kv_;
6081 }
6082 if (kv) {
6083 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6084 if (message_arena != submessage_arena) {
6085 kv = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6086 message_arena, kv, submessage_arena);
6087 }
6088
6089 } else {
6090
6091 }
6092 kv_ = kv;
6093 // @@protoc_insertion_point(field_set_allocated:tensorflow.InsertKeyValueRequest.kv)
6094}
6095
6096// -------------------------------------------------------------------
6097
6098// InsertKeyValueResponse
6099
6100// -------------------------------------------------------------------
6101
6102// GetKeyValueRequest
6103
6104// string key = 1;
6105inline void GetKeyValueRequest::clear_key() {
6106 key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6107}
6108inline const std::string& GetKeyValueRequest::key() const {
6109 // @@protoc_insertion_point(field_get:tensorflow.GetKeyValueRequest.key)
6110 return key_.GetNoArena();
6111}
6112inline void GetKeyValueRequest::set_key(const std::string& value) {
6113
6114 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6115 // @@protoc_insertion_point(field_set:tensorflow.GetKeyValueRequest.key)
6116}
6117inline void GetKeyValueRequest::set_key(std::string&& value) {
6118
6119 key_.SetNoArena(
6120 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6121 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GetKeyValueRequest.key)
6122}
6123inline void GetKeyValueRequest::set_key(const char* value) {
6124 GOOGLE_DCHECK(value != nullptr);
6125
6126 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6127 // @@protoc_insertion_point(field_set_char:tensorflow.GetKeyValueRequest.key)
6128}
6129inline void GetKeyValueRequest::set_key(const char* value, size_t size) {
6130
6131 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6132 ::std::string(reinterpret_cast<const char*>(value), size));
6133 // @@protoc_insertion_point(field_set_pointer:tensorflow.GetKeyValueRequest.key)
6134}
6135inline std::string* GetKeyValueRequest::mutable_key() {
6136
6137 // @@protoc_insertion_point(field_mutable:tensorflow.GetKeyValueRequest.key)
6138 return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6139}
6140inline std::string* GetKeyValueRequest::release_key() {
6141 // @@protoc_insertion_point(field_release:tensorflow.GetKeyValueRequest.key)
6142
6143 return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6144}
6145inline void GetKeyValueRequest::set_allocated_key(std::string* key) {
6146 if (key != nullptr) {
6147
6148 } else {
6149
6150 }
6151 key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
6152 // @@protoc_insertion_point(field_set_allocated:tensorflow.GetKeyValueRequest.key)
6153}
6154
6155// -------------------------------------------------------------------
6156
6157// GetKeyValueResponse
6158
6159// .tensorflow.KeyValueEntry kv = 1;
6160inline bool GetKeyValueResponse::has_kv() const {
6161 return this != internal_default_instance() && kv_ != nullptr;
6162}
6163inline void GetKeyValueResponse::clear_kv() {
6164 if (GetArenaNoVirtual() == nullptr && kv_ != nullptr) {
6165 delete kv_;
6166 }
6167 kv_ = nullptr;
6168}
6169inline const ::tensorflow::KeyValueEntry& GetKeyValueResponse::kv() const {
6170 const ::tensorflow::KeyValueEntry* p = kv_;
6171 // @@protoc_insertion_point(field_get:tensorflow.GetKeyValueResponse.kv)
6172 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::KeyValueEntry*>(
6173 &::tensorflow::_KeyValueEntry_default_instance_);
6174}
6175inline ::tensorflow::KeyValueEntry* GetKeyValueResponse::release_kv() {
6176 // @@protoc_insertion_point(field_release:tensorflow.GetKeyValueResponse.kv)
6177
6178 ::tensorflow::KeyValueEntry* temp = kv_;
6179 kv_ = nullptr;
6180 return temp;
6181}
6182inline ::tensorflow::KeyValueEntry* GetKeyValueResponse::mutable_kv() {
6183
6184 if (kv_ == nullptr) {
6185 auto* p = CreateMaybeMessage<::tensorflow::KeyValueEntry>(GetArenaNoVirtual());
6186 kv_ = p;
6187 }
6188 // @@protoc_insertion_point(field_mutable:tensorflow.GetKeyValueResponse.kv)
6189 return kv_;
6190}
6191inline void GetKeyValueResponse::set_allocated_kv(::tensorflow::KeyValueEntry* kv) {
6192 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6193 if (message_arena == nullptr) {
6194 delete kv_;
6195 }
6196 if (kv) {
6197 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6198 if (message_arena != submessage_arena) {
6199 kv = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6200 message_arena, kv, submessage_arena);
6201 }
6202
6203 } else {
6204
6205 }
6206 kv_ = kv;
6207 // @@protoc_insertion_point(field_set_allocated:tensorflow.GetKeyValueResponse.kv)
6208}
6209
6210// -------------------------------------------------------------------
6211
6212// TryGetKeyValueRequest
6213
6214// string key = 1;
6215inline void TryGetKeyValueRequest::clear_key() {
6216 key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6217}
6218inline const std::string& TryGetKeyValueRequest::key() const {
6219 // @@protoc_insertion_point(field_get:tensorflow.TryGetKeyValueRequest.key)
6220 return key_.GetNoArena();
6221}
6222inline void TryGetKeyValueRequest::set_key(const std::string& value) {
6223
6224 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6225 // @@protoc_insertion_point(field_set:tensorflow.TryGetKeyValueRequest.key)
6226}
6227inline void TryGetKeyValueRequest::set_key(std::string&& value) {
6228
6229 key_.SetNoArena(
6230 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6231 // @@protoc_insertion_point(field_set_rvalue:tensorflow.TryGetKeyValueRequest.key)
6232}
6233inline void TryGetKeyValueRequest::set_key(const char* value) {
6234 GOOGLE_DCHECK(value != nullptr);
6235
6236 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6237 // @@protoc_insertion_point(field_set_char:tensorflow.TryGetKeyValueRequest.key)
6238}
6239inline void TryGetKeyValueRequest::set_key(const char* value, size_t size) {
6240
6241 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6242 ::std::string(reinterpret_cast<const char*>(value), size));
6243 // @@protoc_insertion_point(field_set_pointer:tensorflow.TryGetKeyValueRequest.key)
6244}
6245inline std::string* TryGetKeyValueRequest::mutable_key() {
6246
6247 // @@protoc_insertion_point(field_mutable:tensorflow.TryGetKeyValueRequest.key)
6248 return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6249}
6250inline std::string* TryGetKeyValueRequest::release_key() {
6251 // @@protoc_insertion_point(field_release:tensorflow.TryGetKeyValueRequest.key)
6252
6253 return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6254}
6255inline void TryGetKeyValueRequest::set_allocated_key(std::string* key) {
6256 if (key != nullptr) {
6257
6258 } else {
6259
6260 }
6261 key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
6262 // @@protoc_insertion_point(field_set_allocated:tensorflow.TryGetKeyValueRequest.key)
6263}
6264
6265// -------------------------------------------------------------------
6266
6267// TryGetKeyValueResponse
6268
6269// .tensorflow.KeyValueEntry kv = 1;
6270inline bool TryGetKeyValueResponse::has_kv() const {
6271 return this != internal_default_instance() && kv_ != nullptr;
6272}
6273inline void TryGetKeyValueResponse::clear_kv() {
6274 if (GetArenaNoVirtual() == nullptr && kv_ != nullptr) {
6275 delete kv_;
6276 }
6277 kv_ = nullptr;
6278}
6279inline const ::tensorflow::KeyValueEntry& TryGetKeyValueResponse::kv() const {
6280 const ::tensorflow::KeyValueEntry* p = kv_;
6281 // @@protoc_insertion_point(field_get:tensorflow.TryGetKeyValueResponse.kv)
6282 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::KeyValueEntry*>(
6283 &::tensorflow::_KeyValueEntry_default_instance_);
6284}
6285inline ::tensorflow::KeyValueEntry* TryGetKeyValueResponse::release_kv() {
6286 // @@protoc_insertion_point(field_release:tensorflow.TryGetKeyValueResponse.kv)
6287
6288 ::tensorflow::KeyValueEntry* temp = kv_;
6289 kv_ = nullptr;
6290 return temp;
6291}
6292inline ::tensorflow::KeyValueEntry* TryGetKeyValueResponse::mutable_kv() {
6293
6294 if (kv_ == nullptr) {
6295 auto* p = CreateMaybeMessage<::tensorflow::KeyValueEntry>(GetArenaNoVirtual());
6296 kv_ = p;
6297 }
6298 // @@protoc_insertion_point(field_mutable:tensorflow.TryGetKeyValueResponse.kv)
6299 return kv_;
6300}
6301inline void TryGetKeyValueResponse::set_allocated_kv(::tensorflow::KeyValueEntry* kv) {
6302 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6303 if (message_arena == nullptr) {
6304 delete kv_;
6305 }
6306 if (kv) {
6307 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6308 if (message_arena != submessage_arena) {
6309 kv = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6310 message_arena, kv, submessage_arena);
6311 }
6312
6313 } else {
6314
6315 }
6316 kv_ = kv;
6317 // @@protoc_insertion_point(field_set_allocated:tensorflow.TryGetKeyValueResponse.kv)
6318}
6319
6320// -------------------------------------------------------------------
6321
6322// GetKeyValueDirRequest
6323
6324// string directory_key = 1;
6325inline void GetKeyValueDirRequest::clear_directory_key() {
6326 directory_key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6327}
6328inline const std::string& GetKeyValueDirRequest::directory_key() const {
6329 // @@protoc_insertion_point(field_get:tensorflow.GetKeyValueDirRequest.directory_key)
6330 return directory_key_.GetNoArena();
6331}
6332inline void GetKeyValueDirRequest::set_directory_key(const std::string& value) {
6333
6334 directory_key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6335 // @@protoc_insertion_point(field_set:tensorflow.GetKeyValueDirRequest.directory_key)
6336}
6337inline void GetKeyValueDirRequest::set_directory_key(std::string&& value) {
6338
6339 directory_key_.SetNoArena(
6340 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6341 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GetKeyValueDirRequest.directory_key)
6342}
6343inline void GetKeyValueDirRequest::set_directory_key(const char* value) {
6344 GOOGLE_DCHECK(value != nullptr);
6345
6346 directory_key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6347 // @@protoc_insertion_point(field_set_char:tensorflow.GetKeyValueDirRequest.directory_key)
6348}
6349inline void GetKeyValueDirRequest::set_directory_key(const char* value, size_t size) {
6350
6351 directory_key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6352 ::std::string(reinterpret_cast<const char*>(value), size));
6353 // @@protoc_insertion_point(field_set_pointer:tensorflow.GetKeyValueDirRequest.directory_key)
6354}
6355inline std::string* GetKeyValueDirRequest::mutable_directory_key() {
6356
6357 // @@protoc_insertion_point(field_mutable:tensorflow.GetKeyValueDirRequest.directory_key)
6358 return directory_key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6359}
6360inline std::string* GetKeyValueDirRequest::release_directory_key() {
6361 // @@protoc_insertion_point(field_release:tensorflow.GetKeyValueDirRequest.directory_key)
6362
6363 return directory_key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6364}
6365inline void GetKeyValueDirRequest::set_allocated_directory_key(std::string* directory_key) {
6366 if (directory_key != nullptr) {
6367
6368 } else {
6369
6370 }
6371 directory_key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), directory_key);
6372 // @@protoc_insertion_point(field_set_allocated:tensorflow.GetKeyValueDirRequest.directory_key)
6373}
6374
6375// -------------------------------------------------------------------
6376
6377// GetKeyValueDirResponse
6378
6379// string directory_key = 1;
6380inline void GetKeyValueDirResponse::clear_directory_key() {
6381 directory_key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6382}
6383inline const std::string& GetKeyValueDirResponse::directory_key() const {
6384 // @@protoc_insertion_point(field_get:tensorflow.GetKeyValueDirResponse.directory_key)
6385 return directory_key_.GetNoArena();
6386}
6387inline void GetKeyValueDirResponse::set_directory_key(const std::string& value) {
6388
6389 directory_key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6390 // @@protoc_insertion_point(field_set:tensorflow.GetKeyValueDirResponse.directory_key)
6391}
6392inline void GetKeyValueDirResponse::set_directory_key(std::string&& value) {
6393
6394 directory_key_.SetNoArena(
6395 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6396 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GetKeyValueDirResponse.directory_key)
6397}
6398inline void GetKeyValueDirResponse::set_directory_key(const char* value) {
6399 GOOGLE_DCHECK(value != nullptr);
6400
6401 directory_key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6402 // @@protoc_insertion_point(field_set_char:tensorflow.GetKeyValueDirResponse.directory_key)
6403}
6404inline void GetKeyValueDirResponse::set_directory_key(const char* value, size_t size) {
6405
6406 directory_key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6407 ::std::string(reinterpret_cast<const char*>(value), size));
6408 // @@protoc_insertion_point(field_set_pointer:tensorflow.GetKeyValueDirResponse.directory_key)
6409}
6410inline std::string* GetKeyValueDirResponse::mutable_directory_key() {
6411
6412 // @@protoc_insertion_point(field_mutable:tensorflow.GetKeyValueDirResponse.directory_key)
6413 return directory_key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6414}
6415inline std::string* GetKeyValueDirResponse::release_directory_key() {
6416 // @@protoc_insertion_point(field_release:tensorflow.GetKeyValueDirResponse.directory_key)
6417
6418 return directory_key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6419}
6420inline void GetKeyValueDirResponse::set_allocated_directory_key(std::string* directory_key) {
6421 if (directory_key != nullptr) {
6422
6423 } else {
6424
6425 }
6426 directory_key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), directory_key);
6427 // @@protoc_insertion_point(field_set_allocated:tensorflow.GetKeyValueDirResponse.directory_key)
6428}
6429
6430// repeated .tensorflow.KeyValueEntry kv = 2;
6431inline int GetKeyValueDirResponse::kv_size() const {
6432 return kv_.size();
6433}
6434inline void GetKeyValueDirResponse::clear_kv() {
6435 kv_.Clear();
6436}
6437inline ::tensorflow::KeyValueEntry* GetKeyValueDirResponse::mutable_kv(int index) {
6438 // @@protoc_insertion_point(field_mutable:tensorflow.GetKeyValueDirResponse.kv)
6439 return kv_.Mutable(index);
6440}
6441inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KeyValueEntry >*
6442GetKeyValueDirResponse::mutable_kv() {
6443 // @@protoc_insertion_point(field_mutable_list:tensorflow.GetKeyValueDirResponse.kv)
6444 return &kv_;
6445}
6446inline const ::tensorflow::KeyValueEntry& GetKeyValueDirResponse::kv(int index) const {
6447 // @@protoc_insertion_point(field_get:tensorflow.GetKeyValueDirResponse.kv)
6448 return kv_.Get(index);
6449}
6450inline ::tensorflow::KeyValueEntry* GetKeyValueDirResponse::add_kv() {
6451 // @@protoc_insertion_point(field_add:tensorflow.GetKeyValueDirResponse.kv)
6452 return kv_.Add();
6453}
6454inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::KeyValueEntry >&
6455GetKeyValueDirResponse::kv() const {
6456 // @@protoc_insertion_point(field_list:tensorflow.GetKeyValueDirResponse.kv)
6457 return kv_;
6458}
6459
6460// -------------------------------------------------------------------
6461
6462// DeleteKeyValueRequest
6463
6464// string key = 1;
6465inline void DeleteKeyValueRequest::clear_key() {
6466 key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6467}
6468inline const std::string& DeleteKeyValueRequest::key() const {
6469 // @@protoc_insertion_point(field_get:tensorflow.DeleteKeyValueRequest.key)
6470 return key_.GetNoArena();
6471}
6472inline void DeleteKeyValueRequest::set_key(const std::string& value) {
6473
6474 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6475 // @@protoc_insertion_point(field_set:tensorflow.DeleteKeyValueRequest.key)
6476}
6477inline void DeleteKeyValueRequest::set_key(std::string&& value) {
6478
6479 key_.SetNoArena(
6480 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6481 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DeleteKeyValueRequest.key)
6482}
6483inline void DeleteKeyValueRequest::set_key(const char* value) {
6484 GOOGLE_DCHECK(value != nullptr);
6485
6486 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6487 // @@protoc_insertion_point(field_set_char:tensorflow.DeleteKeyValueRequest.key)
6488}
6489inline void DeleteKeyValueRequest::set_key(const char* value, size_t size) {
6490
6491 key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6492 ::std::string(reinterpret_cast<const char*>(value), size));
6493 // @@protoc_insertion_point(field_set_pointer:tensorflow.DeleteKeyValueRequest.key)
6494}
6495inline std::string* DeleteKeyValueRequest::mutable_key() {
6496
6497 // @@protoc_insertion_point(field_mutable:tensorflow.DeleteKeyValueRequest.key)
6498 return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6499}
6500inline std::string* DeleteKeyValueRequest::release_key() {
6501 // @@protoc_insertion_point(field_release:tensorflow.DeleteKeyValueRequest.key)
6502
6503 return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6504}
6505inline void DeleteKeyValueRequest::set_allocated_key(std::string* key) {
6506 if (key != nullptr) {
6507
6508 } else {
6509
6510 }
6511 key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
6512 // @@protoc_insertion_point(field_set_allocated:tensorflow.DeleteKeyValueRequest.key)
6513}
6514
6515// bool is_directory = 2;
6516inline void DeleteKeyValueRequest::clear_is_directory() {
6517 is_directory_ = false;
6518}
6519inline bool DeleteKeyValueRequest::is_directory() const {
6520 // @@protoc_insertion_point(field_get:tensorflow.DeleteKeyValueRequest.is_directory)
6521 return is_directory_;
6522}
6523inline void DeleteKeyValueRequest::set_is_directory(bool value) {
6524
6525 is_directory_ = value;
6526 // @@protoc_insertion_point(field_set:tensorflow.DeleteKeyValueRequest.is_directory)
6527}
6528
6529// -------------------------------------------------------------------
6530
6531// DeleteKeyValueResponse
6532
6533// -------------------------------------------------------------------
6534
6535// BarrierRequest
6536
6537// string barrier_id = 1;
6538inline void BarrierRequest::clear_barrier_id() {
6539 barrier_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6540}
6541inline const std::string& BarrierRequest::barrier_id() const {
6542 // @@protoc_insertion_point(field_get:tensorflow.BarrierRequest.barrier_id)
6543 return barrier_id_.GetNoArena();
6544}
6545inline void BarrierRequest::set_barrier_id(const std::string& value) {
6546
6547 barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6548 // @@protoc_insertion_point(field_set:tensorflow.BarrierRequest.barrier_id)
6549}
6550inline void BarrierRequest::set_barrier_id(std::string&& value) {
6551
6552 barrier_id_.SetNoArena(
6553 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6554 // @@protoc_insertion_point(field_set_rvalue:tensorflow.BarrierRequest.barrier_id)
6555}
6556inline void BarrierRequest::set_barrier_id(const char* value) {
6557 GOOGLE_DCHECK(value != nullptr);
6558
6559 barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6560 // @@protoc_insertion_point(field_set_char:tensorflow.BarrierRequest.barrier_id)
6561}
6562inline void BarrierRequest::set_barrier_id(const char* value, size_t size) {
6563
6564 barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6565 ::std::string(reinterpret_cast<const char*>(value), size));
6566 // @@protoc_insertion_point(field_set_pointer:tensorflow.BarrierRequest.barrier_id)
6567}
6568inline std::string* BarrierRequest::mutable_barrier_id() {
6569
6570 // @@protoc_insertion_point(field_mutable:tensorflow.BarrierRequest.barrier_id)
6571 return barrier_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6572}
6573inline std::string* BarrierRequest::release_barrier_id() {
6574 // @@protoc_insertion_point(field_release:tensorflow.BarrierRequest.barrier_id)
6575
6576 return barrier_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6577}
6578inline void BarrierRequest::set_allocated_barrier_id(std::string* barrier_id) {
6579 if (barrier_id != nullptr) {
6580
6581 } else {
6582
6583 }
6584 barrier_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), barrier_id);
6585 // @@protoc_insertion_point(field_set_allocated:tensorflow.BarrierRequest.barrier_id)
6586}
6587
6588// int64 barrier_timeout_in_ms = 2;
6589inline void BarrierRequest::clear_barrier_timeout_in_ms() {
6590 barrier_timeout_in_ms_ = PROTOBUF_LONGLONG(0);
6591}
6592inline ::PROTOBUF_NAMESPACE_ID::int64 BarrierRequest::barrier_timeout_in_ms() const {
6593 // @@protoc_insertion_point(field_get:tensorflow.BarrierRequest.barrier_timeout_in_ms)
6594 return barrier_timeout_in_ms_;
6595}
6596inline void BarrierRequest::set_barrier_timeout_in_ms(::PROTOBUF_NAMESPACE_ID::int64 value) {
6597
6598 barrier_timeout_in_ms_ = value;
6599 // @@protoc_insertion_point(field_set:tensorflow.BarrierRequest.barrier_timeout_in_ms)
6600}
6601
6602// repeated .tensorflow.CoordinatedTask tasks = 3;
6603inline int BarrierRequest::tasks_size() const {
6604 return tasks_.size();
6605}
6606inline void BarrierRequest::clear_tasks() {
6607 tasks_.Clear();
6608}
6609inline ::tensorflow::CoordinatedTask* BarrierRequest::mutable_tasks(int index) {
6610 // @@protoc_insertion_point(field_mutable:tensorflow.BarrierRequest.tasks)
6611 return tasks_.Mutable(index);
6612}
6613inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CoordinatedTask >*
6614BarrierRequest::mutable_tasks() {
6615 // @@protoc_insertion_point(field_mutable_list:tensorflow.BarrierRequest.tasks)
6616 return &tasks_;
6617}
6618inline const ::tensorflow::CoordinatedTask& BarrierRequest::tasks(int index) const {
6619 // @@protoc_insertion_point(field_get:tensorflow.BarrierRequest.tasks)
6620 return tasks_.Get(index);
6621}
6622inline ::tensorflow::CoordinatedTask* BarrierRequest::add_tasks() {
6623 // @@protoc_insertion_point(field_add:tensorflow.BarrierRequest.tasks)
6624 return tasks_.Add();
6625}
6626inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::CoordinatedTask >&
6627BarrierRequest::tasks() const {
6628 // @@protoc_insertion_point(field_list:tensorflow.BarrierRequest.tasks)
6629 return tasks_;
6630}
6631
6632// .tensorflow.CoordinatedTask source_task = 4;
6633inline bool BarrierRequest::has_source_task() const {
6634 return this != internal_default_instance() && source_task_ != nullptr;
6635}
6636inline void BarrierRequest::clear_source_task() {
6637 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
6638 delete source_task_;
6639 }
6640 source_task_ = nullptr;
6641}
6642inline const ::tensorflow::CoordinatedTask& BarrierRequest::source_task() const {
6643 const ::tensorflow::CoordinatedTask* p = source_task_;
6644 // @@protoc_insertion_point(field_get:tensorflow.BarrierRequest.source_task)
6645 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
6646 &::tensorflow::_CoordinatedTask_default_instance_);
6647}
6648inline ::tensorflow::CoordinatedTask* BarrierRequest::release_source_task() {
6649 // @@protoc_insertion_point(field_release:tensorflow.BarrierRequest.source_task)
6650
6651 ::tensorflow::CoordinatedTask* temp = source_task_;
6652 source_task_ = nullptr;
6653 return temp;
6654}
6655inline ::tensorflow::CoordinatedTask* BarrierRequest::mutable_source_task() {
6656
6657 if (source_task_ == nullptr) {
6658 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
6659 source_task_ = p;
6660 }
6661 // @@protoc_insertion_point(field_mutable:tensorflow.BarrierRequest.source_task)
6662 return source_task_;
6663}
6664inline void BarrierRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
6665 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6666 if (message_arena == nullptr) {
6667 delete source_task_;
6668 }
6669 if (source_task) {
6670 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6671 if (message_arena != submessage_arena) {
6672 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6673 message_arena, source_task, submessage_arena);
6674 }
6675
6676 } else {
6677
6678 }
6679 source_task_ = source_task;
6680 // @@protoc_insertion_point(field_set_allocated:tensorflow.BarrierRequest.source_task)
6681}
6682
6683// -------------------------------------------------------------------
6684
6685// BarrierResponse
6686
6687// -------------------------------------------------------------------
6688
6689// CancelBarrierRequest
6690
6691// string barrier_id = 1;
6692inline void CancelBarrierRequest::clear_barrier_id() {
6693 barrier_id_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6694}
6695inline const std::string& CancelBarrierRequest::barrier_id() const {
6696 // @@protoc_insertion_point(field_get:tensorflow.CancelBarrierRequest.barrier_id)
6697 return barrier_id_.GetNoArena();
6698}
6699inline void CancelBarrierRequest::set_barrier_id(const std::string& value) {
6700
6701 barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
6702 // @@protoc_insertion_point(field_set:tensorflow.CancelBarrierRequest.barrier_id)
6703}
6704inline void CancelBarrierRequest::set_barrier_id(std::string&& value) {
6705
6706 barrier_id_.SetNoArena(
6707 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
6708 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CancelBarrierRequest.barrier_id)
6709}
6710inline void CancelBarrierRequest::set_barrier_id(const char* value) {
6711 GOOGLE_DCHECK(value != nullptr);
6712
6713 barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
6714 // @@protoc_insertion_point(field_set_char:tensorflow.CancelBarrierRequest.barrier_id)
6715}
6716inline void CancelBarrierRequest::set_barrier_id(const char* value, size_t size) {
6717
6718 barrier_id_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
6719 ::std::string(reinterpret_cast<const char*>(value), size));
6720 // @@protoc_insertion_point(field_set_pointer:tensorflow.CancelBarrierRequest.barrier_id)
6721}
6722inline std::string* CancelBarrierRequest::mutable_barrier_id() {
6723
6724 // @@protoc_insertion_point(field_mutable:tensorflow.CancelBarrierRequest.barrier_id)
6725 return barrier_id_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6726}
6727inline std::string* CancelBarrierRequest::release_barrier_id() {
6728 // @@protoc_insertion_point(field_release:tensorflow.CancelBarrierRequest.barrier_id)
6729
6730 return barrier_id_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
6731}
6732inline void CancelBarrierRequest::set_allocated_barrier_id(std::string* barrier_id) {
6733 if (barrier_id != nullptr) {
6734
6735 } else {
6736
6737 }
6738 barrier_id_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), barrier_id);
6739 // @@protoc_insertion_point(field_set_allocated:tensorflow.CancelBarrierRequest.barrier_id)
6740}
6741
6742// .tensorflow.CoordinatedTask source_task = 2;
6743inline bool CancelBarrierRequest::has_source_task() const {
6744 return this != internal_default_instance() && source_task_ != nullptr;
6745}
6746inline void CancelBarrierRequest::clear_source_task() {
6747 if (GetArenaNoVirtual() == nullptr && source_task_ != nullptr) {
6748 delete source_task_;
6749 }
6750 source_task_ = nullptr;
6751}
6752inline const ::tensorflow::CoordinatedTask& CancelBarrierRequest::source_task() const {
6753 const ::tensorflow::CoordinatedTask* p = source_task_;
6754 // @@protoc_insertion_point(field_get:tensorflow.CancelBarrierRequest.source_task)
6755 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CoordinatedTask*>(
6756 &::tensorflow::_CoordinatedTask_default_instance_);
6757}
6758inline ::tensorflow::CoordinatedTask* CancelBarrierRequest::release_source_task() {
6759 // @@protoc_insertion_point(field_release:tensorflow.CancelBarrierRequest.source_task)
6760
6761 ::tensorflow::CoordinatedTask* temp = source_task_;
6762 source_task_ = nullptr;
6763 return temp;
6764}
6765inline ::tensorflow::CoordinatedTask* CancelBarrierRequest::mutable_source_task() {
6766
6767 if (source_task_ == nullptr) {
6768 auto* p = CreateMaybeMessage<::tensorflow::CoordinatedTask>(GetArenaNoVirtual());
6769 source_task_ = p;
6770 }
6771 // @@protoc_insertion_point(field_mutable:tensorflow.CancelBarrierRequest.source_task)
6772 return source_task_;
6773}
6774inline void CancelBarrierRequest::set_allocated_source_task(::tensorflow::CoordinatedTask* source_task) {
6775 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
6776 if (message_arena == nullptr) {
6777 delete source_task_;
6778 }
6779 if (source_task) {
6780 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
6781 if (message_arena != submessage_arena) {
6782 source_task = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6783 message_arena, source_task, submessage_arena);
6784 }
6785
6786 } else {
6787
6788 }
6789 source_task_ = source_task;
6790 // @@protoc_insertion_point(field_set_allocated:tensorflow.CancelBarrierRequest.source_task)
6791}
6792
6793// -------------------------------------------------------------------
6794
6795// CancelBarrierResponse
6796
6797#ifdef __GNUC__
6798 #pragma GCC diagnostic pop
6799#endif // __GNUC__
6800// -------------------------------------------------------------------
6801
6802// -------------------------------------------------------------------
6803
6804// -------------------------------------------------------------------
6805
6806// -------------------------------------------------------------------
6807
6808// -------------------------------------------------------------------
6809
6810// -------------------------------------------------------------------
6811
6812// -------------------------------------------------------------------
6813
6814// -------------------------------------------------------------------
6815
6816// -------------------------------------------------------------------
6817
6818// -------------------------------------------------------------------
6819
6820// -------------------------------------------------------------------
6821
6822// -------------------------------------------------------------------
6823
6824// -------------------------------------------------------------------
6825
6826// -------------------------------------------------------------------
6827
6828// -------------------------------------------------------------------
6829
6830// -------------------------------------------------------------------
6831
6832// -------------------------------------------------------------------
6833
6834// -------------------------------------------------------------------
6835
6836// -------------------------------------------------------------------
6837
6838// -------------------------------------------------------------------
6839
6840// -------------------------------------------------------------------
6841
6842// -------------------------------------------------------------------
6843
6844// -------------------------------------------------------------------
6845
6846// -------------------------------------------------------------------
6847
6848// -------------------------------------------------------------------
6849
6850// -------------------------------------------------------------------
6851
6852// -------------------------------------------------------------------
6853
6854// -------------------------------------------------------------------
6855
6856// -------------------------------------------------------------------
6857
6858// -------------------------------------------------------------------
6859
6860// -------------------------------------------------------------------
6861
6862// -------------------------------------------------------------------
6863
6864// -------------------------------------------------------------------
6865
6866
6867// @@protoc_insertion_point(namespace_scope)
6868
6869} // namespace tensorflow
6870
6871PROTOBUF_NAMESPACE_OPEN
6872
6873template <> struct is_proto_enum< ::tensorflow::CoordinatedTaskState> : ::std::true_type {};
6874template <>
6875inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::CoordinatedTaskState>() {
6876 return ::tensorflow::CoordinatedTaskState_descriptor();
6877}
6878
6879PROTOBUF_NAMESPACE_CLOSE
6880
6881// @@protoc_insertion_point(global_scope)
6882
6883#include <google/protobuf/port_undef.inc>
6884#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fcoordination_5fservice_2eproto
6885