1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/protobuf/worker.proto
3 
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fworker_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fworker_2eproto
6 
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10 
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22 
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
31 #include <google/protobuf/extension_set.h>  // IWYU pragma: export
32 #include <google/protobuf/any.pb.h>
33 #include "tensorflow/core/framework/cost_graph.pb.h"
34 #include "tensorflow/core/framework/device_attributes.pb.h"
35 #include "tensorflow/core/framework/graph.pb.h"
36 #include "tensorflow/core/framework/step_stats.pb.h"
37 #include "tensorflow/core/framework/tensor.pb.h"
38 #include "tensorflow/core/framework/tensor_shape.pb.h"
39 #include "tensorflow/core/framework/types.pb.h"
40 #include "tensorflow/core/protobuf/config.pb.h"
41 #include "tensorflow/core/protobuf/debug.pb.h"
42 #include "tensorflow/core/protobuf/error_codes.pb.h"
43 #include "tensorflow/core/protobuf/named_tensor.pb.h"
44 #include "tensorflow/core/protobuf/tensorflow_server.pb.h"
45 // @@protoc_insertion_point(includes)
46 #include <google/protobuf/port_def.inc>
47 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fworker_2eproto
48 PROTOBUF_NAMESPACE_OPEN
49 namespace internal {
50 class AnyMetadata;
51 }  // namespace internal
52 PROTOBUF_NAMESPACE_CLOSE
53 
54 // Internal implementation detail -- do not use these members.
55 struct TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto {
56   static const ::uint32_t offsets[];
57 };
58 namespace tensorflow {
59 class CleanupAllRequest;
60 struct CleanupAllRequestDefaultTypeInternal;
61 extern CleanupAllRequestDefaultTypeInternal _CleanupAllRequest_default_instance_;
62 class CleanupAllResponse;
63 struct CleanupAllResponseDefaultTypeInternal;
64 extern CleanupAllResponseDefaultTypeInternal _CleanupAllResponse_default_instance_;
65 class CleanupGraphRequest;
66 struct CleanupGraphRequestDefaultTypeInternal;
67 extern CleanupGraphRequestDefaultTypeInternal _CleanupGraphRequest_default_instance_;
68 class CleanupGraphResponse;
69 struct CleanupGraphResponseDefaultTypeInternal;
70 extern CleanupGraphResponseDefaultTypeInternal _CleanupGraphResponse_default_instance_;
71 class CompleteGroupRequest;
72 struct CompleteGroupRequestDefaultTypeInternal;
73 extern CompleteGroupRequestDefaultTypeInternal _CompleteGroupRequest_default_instance_;
74 class CompleteGroupResponse;
75 struct CompleteGroupResponseDefaultTypeInternal;
76 extern CompleteGroupResponseDefaultTypeInternal _CompleteGroupResponse_default_instance_;
77 class CompleteInstanceRequest;
78 struct CompleteInstanceRequestDefaultTypeInternal;
79 extern CompleteInstanceRequestDefaultTypeInternal _CompleteInstanceRequest_default_instance_;
80 class CompleteInstanceResponse;
81 struct CompleteInstanceResponseDefaultTypeInternal;
82 extern CompleteInstanceResponseDefaultTypeInternal _CompleteInstanceResponse_default_instance_;
83 class CreateWorkerSessionRequest;
84 struct CreateWorkerSessionRequestDefaultTypeInternal;
85 extern CreateWorkerSessionRequestDefaultTypeInternal _CreateWorkerSessionRequest_default_instance_;
86 class CreateWorkerSessionResponse;
87 struct CreateWorkerSessionResponseDefaultTypeInternal;
88 extern CreateWorkerSessionResponseDefaultTypeInternal _CreateWorkerSessionResponse_default_instance_;
89 class DeleteWorkerSessionRequest;
90 struct DeleteWorkerSessionRequestDefaultTypeInternal;
91 extern DeleteWorkerSessionRequestDefaultTypeInternal _DeleteWorkerSessionRequest_default_instance_;
92 class DeleteWorkerSessionResponse;
93 struct DeleteWorkerSessionResponseDefaultTypeInternal;
94 extern DeleteWorkerSessionResponseDefaultTypeInternal _DeleteWorkerSessionResponse_default_instance_;
95 class DeregisterGraphRequest;
96 struct DeregisterGraphRequestDefaultTypeInternal;
97 extern DeregisterGraphRequestDefaultTypeInternal _DeregisterGraphRequest_default_instance_;
98 class DeregisterGraphResponse;
99 struct DeregisterGraphResponseDefaultTypeInternal;
100 extern DeregisterGraphResponseDefaultTypeInternal _DeregisterGraphResponse_default_instance_;
101 class ExecutorOpts;
102 struct ExecutorOptsDefaultTypeInternal;
103 extern ExecutorOptsDefaultTypeInternal _ExecutorOpts_default_instance_;
104 class GetStatusRequest;
105 struct GetStatusRequestDefaultTypeInternal;
106 extern GetStatusRequestDefaultTypeInternal _GetStatusRequest_default_instance_;
107 class GetStatusResponse;
108 struct GetStatusResponseDefaultTypeInternal;
109 extern GetStatusResponseDefaultTypeInternal _GetStatusResponse_default_instance_;
110 class GetStepSequenceRequest;
111 struct GetStepSequenceRequestDefaultTypeInternal;
112 extern GetStepSequenceRequestDefaultTypeInternal _GetStepSequenceRequest_default_instance_;
113 class GetStepSequenceResponse;
114 struct GetStepSequenceResponseDefaultTypeInternal;
115 extern GetStepSequenceResponseDefaultTypeInternal _GetStepSequenceResponse_default_instance_;
116 class LabeledStepStats;
117 struct LabeledStepStatsDefaultTypeInternal;
118 extern LabeledStepStatsDefaultTypeInternal _LabeledStepStats_default_instance_;
119 class LoggingRequest;
120 struct LoggingRequestDefaultTypeInternal;
121 extern LoggingRequestDefaultTypeInternal _LoggingRequest_default_instance_;
122 class LoggingResponse;
123 struct LoggingResponseDefaultTypeInternal;
124 extern LoggingResponseDefaultTypeInternal _LoggingResponse_default_instance_;
125 class MarkRecvFinishedRequest;
126 struct MarkRecvFinishedRequestDefaultTypeInternal;
127 extern MarkRecvFinishedRequestDefaultTypeInternal _MarkRecvFinishedRequest_default_instance_;
128 class MarkRecvFinishedResponse;
129 struct MarkRecvFinishedResponseDefaultTypeInternal;
130 extern MarkRecvFinishedResponseDefaultTypeInternal _MarkRecvFinishedResponse_default_instance_;
131 class RecvBufRequest;
132 struct RecvBufRequestDefaultTypeInternal;
133 extern RecvBufRequestDefaultTypeInternal _RecvBufRequest_default_instance_;
134 class RecvBufResponse;
135 struct RecvBufResponseDefaultTypeInternal;
136 extern RecvBufResponseDefaultTypeInternal _RecvBufResponse_default_instance_;
137 class RecvTensorRequest;
138 struct RecvTensorRequestDefaultTypeInternal;
139 extern RecvTensorRequestDefaultTypeInternal _RecvTensorRequest_default_instance_;
140 class RecvTensorResponse;
141 struct RecvTensorResponseDefaultTypeInternal;
142 extern RecvTensorResponseDefaultTypeInternal _RecvTensorResponse_default_instance_;
143 class RegisterGraphRequest;
144 struct RegisterGraphRequestDefaultTypeInternal;
145 extern RegisterGraphRequestDefaultTypeInternal _RegisterGraphRequest_default_instance_;
146 class RegisterGraphResponse;
147 struct RegisterGraphResponseDefaultTypeInternal;
148 extern RegisterGraphResponseDefaultTypeInternal _RegisterGraphResponse_default_instance_;
149 class RunGraphRequest;
150 struct RunGraphRequestDefaultTypeInternal;
151 extern RunGraphRequestDefaultTypeInternal _RunGraphRequest_default_instance_;
152 class RunGraphResponse;
153 struct RunGraphResponseDefaultTypeInternal;
154 extern RunGraphResponseDefaultTypeInternal _RunGraphResponse_default_instance_;
155 class StepSequence;
156 struct StepSequenceDefaultTypeInternal;
157 extern StepSequenceDefaultTypeInternal _StepSequence_default_instance_;
158 class TraceOpts;
159 struct TraceOptsDefaultTypeInternal;
160 extern TraceOptsDefaultTypeInternal _TraceOpts_default_instance_;
161 class TracingRequest;
162 struct TracingRequestDefaultTypeInternal;
163 extern TracingRequestDefaultTypeInternal _TracingRequest_default_instance_;
164 class TracingResponse;
165 struct TracingResponseDefaultTypeInternal;
166 extern TracingResponseDefaultTypeInternal _TracingResponse_default_instance_;
167 }  // namespace tensorflow
168 PROTOBUF_NAMESPACE_OPEN
169 template<> ::tensorflow::CleanupAllRequest* Arena::CreateMaybeMessage<::tensorflow::CleanupAllRequest>(Arena*);
170 template<> ::tensorflow::CleanupAllResponse* Arena::CreateMaybeMessage<::tensorflow::CleanupAllResponse>(Arena*);
171 template<> ::tensorflow::CleanupGraphRequest* Arena::CreateMaybeMessage<::tensorflow::CleanupGraphRequest>(Arena*);
172 template<> ::tensorflow::CleanupGraphResponse* Arena::CreateMaybeMessage<::tensorflow::CleanupGraphResponse>(Arena*);
173 template<> ::tensorflow::CompleteGroupRequest* Arena::CreateMaybeMessage<::tensorflow::CompleteGroupRequest>(Arena*);
174 template<> ::tensorflow::CompleteGroupResponse* Arena::CreateMaybeMessage<::tensorflow::CompleteGroupResponse>(Arena*);
175 template<> ::tensorflow::CompleteInstanceRequest* Arena::CreateMaybeMessage<::tensorflow::CompleteInstanceRequest>(Arena*);
176 template<> ::tensorflow::CompleteInstanceResponse* Arena::CreateMaybeMessage<::tensorflow::CompleteInstanceResponse>(Arena*);
177 template<> ::tensorflow::CreateWorkerSessionRequest* Arena::CreateMaybeMessage<::tensorflow::CreateWorkerSessionRequest>(Arena*);
178 template<> ::tensorflow::CreateWorkerSessionResponse* Arena::CreateMaybeMessage<::tensorflow::CreateWorkerSessionResponse>(Arena*);
179 template<> ::tensorflow::DeleteWorkerSessionRequest* Arena::CreateMaybeMessage<::tensorflow::DeleteWorkerSessionRequest>(Arena*);
180 template<> ::tensorflow::DeleteWorkerSessionResponse* Arena::CreateMaybeMessage<::tensorflow::DeleteWorkerSessionResponse>(Arena*);
181 template<> ::tensorflow::DeregisterGraphRequest* Arena::CreateMaybeMessage<::tensorflow::DeregisterGraphRequest>(Arena*);
182 template<> ::tensorflow::DeregisterGraphResponse* Arena::CreateMaybeMessage<::tensorflow::DeregisterGraphResponse>(Arena*);
183 template<> ::tensorflow::ExecutorOpts* Arena::CreateMaybeMessage<::tensorflow::ExecutorOpts>(Arena*);
184 template<> ::tensorflow::GetStatusRequest* Arena::CreateMaybeMessage<::tensorflow::GetStatusRequest>(Arena*);
185 template<> ::tensorflow::GetStatusResponse* Arena::CreateMaybeMessage<::tensorflow::GetStatusResponse>(Arena*);
186 template<> ::tensorflow::GetStepSequenceRequest* Arena::CreateMaybeMessage<::tensorflow::GetStepSequenceRequest>(Arena*);
187 template<> ::tensorflow::GetStepSequenceResponse* Arena::CreateMaybeMessage<::tensorflow::GetStepSequenceResponse>(Arena*);
188 template<> ::tensorflow::LabeledStepStats* Arena::CreateMaybeMessage<::tensorflow::LabeledStepStats>(Arena*);
189 template<> ::tensorflow::LoggingRequest* Arena::CreateMaybeMessage<::tensorflow::LoggingRequest>(Arena*);
190 template<> ::tensorflow::LoggingResponse* Arena::CreateMaybeMessage<::tensorflow::LoggingResponse>(Arena*);
191 template<> ::tensorflow::MarkRecvFinishedRequest* Arena::CreateMaybeMessage<::tensorflow::MarkRecvFinishedRequest>(Arena*);
192 template<> ::tensorflow::MarkRecvFinishedResponse* Arena::CreateMaybeMessage<::tensorflow::MarkRecvFinishedResponse>(Arena*);
193 template<> ::tensorflow::RecvBufRequest* Arena::CreateMaybeMessage<::tensorflow::RecvBufRequest>(Arena*);
194 template<> ::tensorflow::RecvBufResponse* Arena::CreateMaybeMessage<::tensorflow::RecvBufResponse>(Arena*);
195 template<> ::tensorflow::RecvTensorRequest* Arena::CreateMaybeMessage<::tensorflow::RecvTensorRequest>(Arena*);
196 template<> ::tensorflow::RecvTensorResponse* Arena::CreateMaybeMessage<::tensorflow::RecvTensorResponse>(Arena*);
197 template<> ::tensorflow::RegisterGraphRequest* Arena::CreateMaybeMessage<::tensorflow::RegisterGraphRequest>(Arena*);
198 template<> ::tensorflow::RegisterGraphResponse* Arena::CreateMaybeMessage<::tensorflow::RegisterGraphResponse>(Arena*);
199 template<> ::tensorflow::RunGraphRequest* Arena::CreateMaybeMessage<::tensorflow::RunGraphRequest>(Arena*);
200 template<> ::tensorflow::RunGraphResponse* Arena::CreateMaybeMessage<::tensorflow::RunGraphResponse>(Arena*);
201 template<> ::tensorflow::StepSequence* Arena::CreateMaybeMessage<::tensorflow::StepSequence>(Arena*);
202 template<> ::tensorflow::TraceOpts* Arena::CreateMaybeMessage<::tensorflow::TraceOpts>(Arena*);
203 template<> ::tensorflow::TracingRequest* Arena::CreateMaybeMessage<::tensorflow::TracingRequest>(Arena*);
204 template<> ::tensorflow::TracingResponse* Arena::CreateMaybeMessage<::tensorflow::TracingResponse>(Arena*);
205 PROTOBUF_NAMESPACE_CLOSE
206 namespace tensorflow {
207 
208 // ===================================================================
209 
210 class GetStatusRequest final :
211     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.GetStatusRequest) */ {
212  public:
GetStatusRequest()213   inline GetStatusRequest() : GetStatusRequest(nullptr) {}
214   ~GetStatusRequest() override;
215   explicit PROTOBUF_CONSTEXPR GetStatusRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
216 
217   GetStatusRequest(const GetStatusRequest& from);
GetStatusRequest(GetStatusRequest && from)218   GetStatusRequest(GetStatusRequest&& from) noexcept
219     : GetStatusRequest() {
220     *this = ::std::move(from);
221   }
222 
223   inline GetStatusRequest& operator=(const GetStatusRequest& from) {
224     if (this == &from) return *this;
225     CopyFrom(from);
226     return *this;
227   }
228   inline GetStatusRequest& operator=(GetStatusRequest&& from) noexcept {
229     if (this == &from) return *this;
230     if (GetOwningArena() == from.GetOwningArena()
231   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
232         && GetOwningArena() != nullptr
233   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
234     ) {
235       InternalSwap(&from);
236     } else {
237       CopyFrom(from);
238     }
239     return *this;
240   }
241 
default_instance()242   static const GetStatusRequest& default_instance() {
243     return *internal_default_instance();
244   }
internal_default_instance()245   static inline const GetStatusRequest* internal_default_instance() {
246     return reinterpret_cast<const GetStatusRequest*>(
247                &_GetStatusRequest_default_instance_);
248   }
249   static constexpr int kIndexInFileMessages =
250     0;
251 
swap(GetStatusRequest & a,GetStatusRequest & b)252   friend void swap(GetStatusRequest& a, GetStatusRequest& b) {
253     a.Swap(&b);
254   }
Swap(GetStatusRequest * other)255   inline void Swap(GetStatusRequest* other) {
256     if (other == this) return;
257   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
258     if (GetOwningArena() != nullptr &&
259         GetOwningArena() == other->GetOwningArena()) {
260    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
261     if (GetOwningArena() == other->GetOwningArena()) {
262   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
263       InternalSwap(other);
264     } else {
265       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
266     }
267   }
268   void UnsafeArenaSwap(GetStatusRequest* other) {
269     if (other == this) return;
270     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
271     InternalSwap(other);
272   }
273 
274   // implements Message ----------------------------------------------
275 
276   GetStatusRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
277     return CreateMaybeMessage<GetStatusRequest>(arena);
278   }
279   GetStatusRequest* New() const {
280     return New(nullptr);
281   }
282   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
283   void CopyFrom(const GetStatusRequest& from);
284   void MergeFrom(const GetStatusRequest& from);
285   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
286   bool IsInitialized() const final;
287 
288   size_t ByteSizeLong() const final;
289   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
290   ::uint8_t* _InternalSerialize(
291       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
292   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
293 
294   private:
295   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
296   void SharedDtor();
297   void SetCachedSize(int size) const;
298   void InternalSwap(GetStatusRequest* other);
299 
300   private:
301   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
302   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
303     return "tensorflow.GetStatusRequest";
304   }
305   protected:
306   explicit GetStatusRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
307                        bool is_message_owned = false);
308   public:
309 
310   std::string GetTypeName() const final;
311 
312   // nested types ----------------------------------------------------
313 
314   // accessors -------------------------------------------------------
315 
316   // @@protoc_insertion_point(class_scope:tensorflow.GetStatusRequest)
317  private:
318   class _Internal;
319 
320   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
321   typedef void InternalArenaConstructable_;
322   typedef void DestructorSkippable_;
323   struct Impl_ {
324     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
325   };
326   union { Impl_ _impl_; };
327   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
328 };
329 // -------------------------------------------------------------------
330 
331 class GetStatusResponse final :
332     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.GetStatusResponse) */ {
333  public:
GetStatusResponse()334   inline GetStatusResponse() : GetStatusResponse(nullptr) {}
335   ~GetStatusResponse() override;
336   explicit PROTOBUF_CONSTEXPR GetStatusResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
337 
338   GetStatusResponse(const GetStatusResponse& from);
GetStatusResponse(GetStatusResponse && from)339   GetStatusResponse(GetStatusResponse&& from) noexcept
340     : GetStatusResponse() {
341     *this = ::std::move(from);
342   }
343 
344   inline GetStatusResponse& operator=(const GetStatusResponse& from) {
345     if (this == &from) return *this;
346     CopyFrom(from);
347     return *this;
348   }
349   inline GetStatusResponse& operator=(GetStatusResponse&& from) noexcept {
350     if (this == &from) return *this;
351     if (GetOwningArena() == from.GetOwningArena()
352   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
353         && GetOwningArena() != nullptr
354   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
355     ) {
356       InternalSwap(&from);
357     } else {
358       CopyFrom(from);
359     }
360     return *this;
361   }
362 
default_instance()363   static const GetStatusResponse& default_instance() {
364     return *internal_default_instance();
365   }
internal_default_instance()366   static inline const GetStatusResponse* internal_default_instance() {
367     return reinterpret_cast<const GetStatusResponse*>(
368                &_GetStatusResponse_default_instance_);
369   }
370   static constexpr int kIndexInFileMessages =
371     1;
372 
swap(GetStatusResponse & a,GetStatusResponse & b)373   friend void swap(GetStatusResponse& a, GetStatusResponse& b) {
374     a.Swap(&b);
375   }
Swap(GetStatusResponse * other)376   inline void Swap(GetStatusResponse* other) {
377     if (other == this) return;
378   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
379     if (GetOwningArena() != nullptr &&
380         GetOwningArena() == other->GetOwningArena()) {
381    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
382     if (GetOwningArena() == other->GetOwningArena()) {
383   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
384       InternalSwap(other);
385     } else {
386       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
387     }
388   }
389   void UnsafeArenaSwap(GetStatusResponse* other) {
390     if (other == this) return;
391     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
392     InternalSwap(other);
393   }
394 
395   // implements Message ----------------------------------------------
396 
397   GetStatusResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
398     return CreateMaybeMessage<GetStatusResponse>(arena);
399   }
400   GetStatusResponse* New() const {
401     return New(nullptr);
402   }
403   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
404   void CopyFrom(const GetStatusResponse& from);
405   void MergeFrom(const GetStatusResponse& from);
406   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
407   bool IsInitialized() const final;
408 
409   size_t ByteSizeLong() const final;
410   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
411   ::uint8_t* _InternalSerialize(
412       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
413   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
414 
415   private:
416   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
417   void SharedDtor();
418   void SetCachedSize(int size) const;
419   void InternalSwap(GetStatusResponse* other);
420 
421   private:
422   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
423   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
424     return "tensorflow.GetStatusResponse";
425   }
426   protected:
427   explicit GetStatusResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
428                        bool is_message_owned = false);
429   public:
430 
431   std::string GetTypeName() const final;
432 
433   // nested types ----------------------------------------------------
434 
435   // accessors -------------------------------------------------------
436 
437   enum : int {
438     kDeviceAttributesFieldNumber = 1,
439   };
440   // repeated .tensorflow.DeviceAttributes device_attributes = 1;
441   int device_attributes_size() const;
442   private:
443   int _internal_device_attributes_size() const;
444   public:
445   void clear_device_attributes();
446   ::tensorflow::DeviceAttributes* mutable_device_attributes(int index);
447   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
448       mutable_device_attributes();
449   private:
450   const ::tensorflow::DeviceAttributes& _internal_device_attributes(int index) const;
451   ::tensorflow::DeviceAttributes* _internal_add_device_attributes();
452   public:
453   const ::tensorflow::DeviceAttributes& device_attributes(int index) const;
454   ::tensorflow::DeviceAttributes* add_device_attributes();
455   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
456       device_attributes() const;
457 
458   // @@protoc_insertion_point(class_scope:tensorflow.GetStatusResponse)
459  private:
460   class _Internal;
461 
462   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
463   typedef void InternalArenaConstructable_;
464   typedef void DestructorSkippable_;
465   struct Impl_ {
466     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes > device_attributes_;
467     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
468   };
469   union { Impl_ _impl_; };
470   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
471 };
472 // -------------------------------------------------------------------
473 
474 class CreateWorkerSessionRequest final :
475     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CreateWorkerSessionRequest) */ {
476  public:
CreateWorkerSessionRequest()477   inline CreateWorkerSessionRequest() : CreateWorkerSessionRequest(nullptr) {}
478   ~CreateWorkerSessionRequest() override;
479   explicit PROTOBUF_CONSTEXPR CreateWorkerSessionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
480 
481   CreateWorkerSessionRequest(const CreateWorkerSessionRequest& from);
CreateWorkerSessionRequest(CreateWorkerSessionRequest && from)482   CreateWorkerSessionRequest(CreateWorkerSessionRequest&& from) noexcept
483     : CreateWorkerSessionRequest() {
484     *this = ::std::move(from);
485   }
486 
487   inline CreateWorkerSessionRequest& operator=(const CreateWorkerSessionRequest& from) {
488     if (this == &from) return *this;
489     CopyFrom(from);
490     return *this;
491   }
492   inline CreateWorkerSessionRequest& operator=(CreateWorkerSessionRequest&& from) noexcept {
493     if (this == &from) return *this;
494     if (GetOwningArena() == from.GetOwningArena()
495   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
496         && GetOwningArena() != nullptr
497   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
498     ) {
499       InternalSwap(&from);
500     } else {
501       CopyFrom(from);
502     }
503     return *this;
504   }
505 
default_instance()506   static const CreateWorkerSessionRequest& default_instance() {
507     return *internal_default_instance();
508   }
internal_default_instance()509   static inline const CreateWorkerSessionRequest* internal_default_instance() {
510     return reinterpret_cast<const CreateWorkerSessionRequest*>(
511                &_CreateWorkerSessionRequest_default_instance_);
512   }
513   static constexpr int kIndexInFileMessages =
514     2;
515 
swap(CreateWorkerSessionRequest & a,CreateWorkerSessionRequest & b)516   friend void swap(CreateWorkerSessionRequest& a, CreateWorkerSessionRequest& b) {
517     a.Swap(&b);
518   }
Swap(CreateWorkerSessionRequest * other)519   inline void Swap(CreateWorkerSessionRequest* other) {
520     if (other == this) return;
521   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
522     if (GetOwningArena() != nullptr &&
523         GetOwningArena() == other->GetOwningArena()) {
524    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
525     if (GetOwningArena() == other->GetOwningArena()) {
526   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
527       InternalSwap(other);
528     } else {
529       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
530     }
531   }
532   void UnsafeArenaSwap(CreateWorkerSessionRequest* other) {
533     if (other == this) return;
534     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
535     InternalSwap(other);
536   }
537 
538   // implements Message ----------------------------------------------
539 
540   CreateWorkerSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
541     return CreateMaybeMessage<CreateWorkerSessionRequest>(arena);
542   }
543   CreateWorkerSessionRequest* New() const {
544     return New(nullptr);
545   }
546   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
547   void CopyFrom(const CreateWorkerSessionRequest& from);
548   void MergeFrom(const CreateWorkerSessionRequest& from);
549   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
550   bool IsInitialized() const final;
551 
552   size_t ByteSizeLong() const final;
553   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
554   ::uint8_t* _InternalSerialize(
555       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
556   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
557 
558   private:
559   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
560   void SharedDtor();
561   void SetCachedSize(int size) const;
562   void InternalSwap(CreateWorkerSessionRequest* other);
563 
564   private:
565   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
566   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
567     return "tensorflow.CreateWorkerSessionRequest";
568   }
569   protected:
570   explicit CreateWorkerSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
571                        bool is_message_owned = false);
572   public:
573 
574   std::string GetTypeName() const final;
575 
576   // nested types ----------------------------------------------------
577 
578   // accessors -------------------------------------------------------
579 
580   enum : int {
581     kClusterDeviceAttributesFieldNumber = 4,
582     kSessionHandleFieldNumber = 1,
583     kMasterTaskFieldNumber = 5,
584     kServerDefFieldNumber = 2,
585     kMasterIncarnationFieldNumber = 6,
586     kIsolateSessionStateFieldNumber = 3,
587   };
588   // repeated .tensorflow.DeviceAttributes cluster_device_attributes = 4;
589   int cluster_device_attributes_size() const;
590   private:
591   int _internal_cluster_device_attributes_size() const;
592   public:
593   void clear_cluster_device_attributes();
594   ::tensorflow::DeviceAttributes* mutable_cluster_device_attributes(int index);
595   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
596       mutable_cluster_device_attributes();
597   private:
598   const ::tensorflow::DeviceAttributes& _internal_cluster_device_attributes(int index) const;
599   ::tensorflow::DeviceAttributes* _internal_add_cluster_device_attributes();
600   public:
601   const ::tensorflow::DeviceAttributes& cluster_device_attributes(int index) const;
602   ::tensorflow::DeviceAttributes* add_cluster_device_attributes();
603   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
604       cluster_device_attributes() const;
605 
606   // string session_handle = 1;
607   void clear_session_handle();
608   const std::string& session_handle() const;
609   template <typename ArgT0 = const std::string&, typename... ArgT>
610   void set_session_handle(ArgT0&& arg0, ArgT... args);
611   std::string* mutable_session_handle();
612   PROTOBUF_NODISCARD std::string* release_session_handle();
613   void set_allocated_session_handle(std::string* session_handle);
614   private:
615   const std::string& _internal_session_handle() const;
616   inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
617   std::string* _internal_mutable_session_handle();
618   public:
619 
620   // string master_task = 5;
621   void clear_master_task();
622   const std::string& master_task() const;
623   template <typename ArgT0 = const std::string&, typename... ArgT>
624   void set_master_task(ArgT0&& arg0, ArgT... args);
625   std::string* mutable_master_task();
626   PROTOBUF_NODISCARD std::string* release_master_task();
627   void set_allocated_master_task(std::string* master_task);
628   private:
629   const std::string& _internal_master_task() const;
630   inline PROTOBUF_ALWAYS_INLINE void _internal_set_master_task(const std::string& value);
631   std::string* _internal_mutable_master_task();
632   public:
633 
634   // .tensorflow.ServerDef server_def = 2;
635   bool has_server_def() const;
636   private:
637   bool _internal_has_server_def() const;
638   public:
639   void clear_server_def();
640   const ::tensorflow::ServerDef& server_def() const;
641   PROTOBUF_NODISCARD ::tensorflow::ServerDef* release_server_def();
642   ::tensorflow::ServerDef* mutable_server_def();
643   void set_allocated_server_def(::tensorflow::ServerDef* server_def);
644   private:
645   const ::tensorflow::ServerDef& _internal_server_def() const;
646   ::tensorflow::ServerDef* _internal_mutable_server_def();
647   public:
648   void unsafe_arena_set_allocated_server_def(
649       ::tensorflow::ServerDef* server_def);
650   ::tensorflow::ServerDef* unsafe_arena_release_server_def();
651 
652   // int64 master_incarnation = 6;
653   void clear_master_incarnation();
654   ::int64_t master_incarnation() const;
655   void set_master_incarnation(::int64_t value);
656   private:
657   ::int64_t _internal_master_incarnation() const;
658   void _internal_set_master_incarnation(::int64_t value);
659   public:
660 
661   // bool isolate_session_state = 3;
662   void clear_isolate_session_state();
663   bool isolate_session_state() const;
664   void set_isolate_session_state(bool value);
665   private:
666   bool _internal_isolate_session_state() const;
667   void _internal_set_isolate_session_state(bool value);
668   public:
669 
670   // @@protoc_insertion_point(class_scope:tensorflow.CreateWorkerSessionRequest)
671  private:
672   class _Internal;
673 
674   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
675   typedef void InternalArenaConstructable_;
676   typedef void DestructorSkippable_;
677   struct Impl_ {
678     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes > cluster_device_attributes_;
679     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
680     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr master_task_;
681     ::tensorflow::ServerDef* server_def_;
682     ::int64_t master_incarnation_;
683     bool isolate_session_state_;
684     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
685   };
686   union { Impl_ _impl_; };
687   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
688 };
689 // -------------------------------------------------------------------
690 
691 class CreateWorkerSessionResponse final :
692     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CreateWorkerSessionResponse) */ {
693  public:
CreateWorkerSessionResponse()694   inline CreateWorkerSessionResponse() : CreateWorkerSessionResponse(nullptr) {}
695   ~CreateWorkerSessionResponse() override;
696   explicit PROTOBUF_CONSTEXPR CreateWorkerSessionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
697 
698   CreateWorkerSessionResponse(const CreateWorkerSessionResponse& from);
CreateWorkerSessionResponse(CreateWorkerSessionResponse && from)699   CreateWorkerSessionResponse(CreateWorkerSessionResponse&& from) noexcept
700     : CreateWorkerSessionResponse() {
701     *this = ::std::move(from);
702   }
703 
704   inline CreateWorkerSessionResponse& operator=(const CreateWorkerSessionResponse& from) {
705     if (this == &from) return *this;
706     CopyFrom(from);
707     return *this;
708   }
709   inline CreateWorkerSessionResponse& operator=(CreateWorkerSessionResponse&& from) noexcept {
710     if (this == &from) return *this;
711     if (GetOwningArena() == from.GetOwningArena()
712   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
713         && GetOwningArena() != nullptr
714   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
715     ) {
716       InternalSwap(&from);
717     } else {
718       CopyFrom(from);
719     }
720     return *this;
721   }
722 
default_instance()723   static const CreateWorkerSessionResponse& default_instance() {
724     return *internal_default_instance();
725   }
internal_default_instance()726   static inline const CreateWorkerSessionResponse* internal_default_instance() {
727     return reinterpret_cast<const CreateWorkerSessionResponse*>(
728                &_CreateWorkerSessionResponse_default_instance_);
729   }
730   static constexpr int kIndexInFileMessages =
731     3;
732 
swap(CreateWorkerSessionResponse & a,CreateWorkerSessionResponse & b)733   friend void swap(CreateWorkerSessionResponse& a, CreateWorkerSessionResponse& b) {
734     a.Swap(&b);
735   }
Swap(CreateWorkerSessionResponse * other)736   inline void Swap(CreateWorkerSessionResponse* other) {
737     if (other == this) return;
738   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
739     if (GetOwningArena() != nullptr &&
740         GetOwningArena() == other->GetOwningArena()) {
741    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
742     if (GetOwningArena() == other->GetOwningArena()) {
743   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
744       InternalSwap(other);
745     } else {
746       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
747     }
748   }
749   void UnsafeArenaSwap(CreateWorkerSessionResponse* other) {
750     if (other == this) return;
751     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
752     InternalSwap(other);
753   }
754 
755   // implements Message ----------------------------------------------
756 
757   CreateWorkerSessionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
758     return CreateMaybeMessage<CreateWorkerSessionResponse>(arena);
759   }
760   CreateWorkerSessionResponse* New() const {
761     return New(nullptr);
762   }
763   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
764   void CopyFrom(const CreateWorkerSessionResponse& from);
765   void MergeFrom(const CreateWorkerSessionResponse& from);
766   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
767   bool IsInitialized() const final;
768 
769   size_t ByteSizeLong() const final;
770   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
771   ::uint8_t* _InternalSerialize(
772       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
773   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
774 
775   private:
776   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
777   void SharedDtor();
778   void SetCachedSize(int size) const;
779   void InternalSwap(CreateWorkerSessionResponse* other);
780 
781   private:
782   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
783   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
784     return "tensorflow.CreateWorkerSessionResponse";
785   }
786   protected:
787   explicit CreateWorkerSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
788                        bool is_message_owned = false);
789   public:
790 
791   std::string GetTypeName() const final;
792 
793   // nested types ----------------------------------------------------
794 
795   // accessors -------------------------------------------------------
796 
797   // @@protoc_insertion_point(class_scope:tensorflow.CreateWorkerSessionResponse)
798  private:
799   class _Internal;
800 
801   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
802   typedef void InternalArenaConstructable_;
803   typedef void DestructorSkippable_;
804   struct Impl_ {
805     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
806   };
807   union { Impl_ _impl_; };
808   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
809 };
810 // -------------------------------------------------------------------
811 
812 class DeleteWorkerSessionRequest final :
813     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DeleteWorkerSessionRequest) */ {
814  public:
DeleteWorkerSessionRequest()815   inline DeleteWorkerSessionRequest() : DeleteWorkerSessionRequest(nullptr) {}
816   ~DeleteWorkerSessionRequest() override;
817   explicit PROTOBUF_CONSTEXPR DeleteWorkerSessionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
818 
819   DeleteWorkerSessionRequest(const DeleteWorkerSessionRequest& from);
DeleteWorkerSessionRequest(DeleteWorkerSessionRequest && from)820   DeleteWorkerSessionRequest(DeleteWorkerSessionRequest&& from) noexcept
821     : DeleteWorkerSessionRequest() {
822     *this = ::std::move(from);
823   }
824 
825   inline DeleteWorkerSessionRequest& operator=(const DeleteWorkerSessionRequest& from) {
826     if (this == &from) return *this;
827     CopyFrom(from);
828     return *this;
829   }
830   inline DeleteWorkerSessionRequest& operator=(DeleteWorkerSessionRequest&& from) noexcept {
831     if (this == &from) return *this;
832     if (GetOwningArena() == from.GetOwningArena()
833   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
834         && GetOwningArena() != nullptr
835   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
836     ) {
837       InternalSwap(&from);
838     } else {
839       CopyFrom(from);
840     }
841     return *this;
842   }
843 
default_instance()844   static const DeleteWorkerSessionRequest& default_instance() {
845     return *internal_default_instance();
846   }
internal_default_instance()847   static inline const DeleteWorkerSessionRequest* internal_default_instance() {
848     return reinterpret_cast<const DeleteWorkerSessionRequest*>(
849                &_DeleteWorkerSessionRequest_default_instance_);
850   }
851   static constexpr int kIndexInFileMessages =
852     4;
853 
swap(DeleteWorkerSessionRequest & a,DeleteWorkerSessionRequest & b)854   friend void swap(DeleteWorkerSessionRequest& a, DeleteWorkerSessionRequest& b) {
855     a.Swap(&b);
856   }
Swap(DeleteWorkerSessionRequest * other)857   inline void Swap(DeleteWorkerSessionRequest* other) {
858     if (other == this) return;
859   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
860     if (GetOwningArena() != nullptr &&
861         GetOwningArena() == other->GetOwningArena()) {
862    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
863     if (GetOwningArena() == other->GetOwningArena()) {
864   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
865       InternalSwap(other);
866     } else {
867       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
868     }
869   }
870   void UnsafeArenaSwap(DeleteWorkerSessionRequest* other) {
871     if (other == this) return;
872     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
873     InternalSwap(other);
874   }
875 
876   // implements Message ----------------------------------------------
877 
878   DeleteWorkerSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
879     return CreateMaybeMessage<DeleteWorkerSessionRequest>(arena);
880   }
881   DeleteWorkerSessionRequest* New() const {
882     return New(nullptr);
883   }
884   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
885   void CopyFrom(const DeleteWorkerSessionRequest& from);
886   void MergeFrom(const DeleteWorkerSessionRequest& from);
887   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
888   bool IsInitialized() const final;
889 
890   size_t ByteSizeLong() const final;
891   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
892   ::uint8_t* _InternalSerialize(
893       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
894   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
895 
896   private:
897   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
898   void SharedDtor();
899   void SetCachedSize(int size) const;
900   void InternalSwap(DeleteWorkerSessionRequest* other);
901 
902   private:
903   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
904   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
905     return "tensorflow.DeleteWorkerSessionRequest";
906   }
907   protected:
908   explicit DeleteWorkerSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
909                        bool is_message_owned = false);
910   public:
911 
912   std::string GetTypeName() const final;
913 
914   // nested types ----------------------------------------------------
915 
916   // accessors -------------------------------------------------------
917 
918   enum : int {
919     kSessionHandleFieldNumber = 1,
920   };
921   // string session_handle = 1;
922   void clear_session_handle();
923   const std::string& session_handle() const;
924   template <typename ArgT0 = const std::string&, typename... ArgT>
925   void set_session_handle(ArgT0&& arg0, ArgT... args);
926   std::string* mutable_session_handle();
927   PROTOBUF_NODISCARD std::string* release_session_handle();
928   void set_allocated_session_handle(std::string* session_handle);
929   private:
930   const std::string& _internal_session_handle() const;
931   inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
932   std::string* _internal_mutable_session_handle();
933   public:
934 
935   // @@protoc_insertion_point(class_scope:tensorflow.DeleteWorkerSessionRequest)
936  private:
937   class _Internal;
938 
939   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
940   typedef void InternalArenaConstructable_;
941   typedef void DestructorSkippable_;
942   struct Impl_ {
943     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
944     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
945   };
946   union { Impl_ _impl_; };
947   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
948 };
949 // -------------------------------------------------------------------
950 
951 class DeleteWorkerSessionResponse final :
952     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DeleteWorkerSessionResponse) */ {
953  public:
DeleteWorkerSessionResponse()954   inline DeleteWorkerSessionResponse() : DeleteWorkerSessionResponse(nullptr) {}
955   ~DeleteWorkerSessionResponse() override;
956   explicit PROTOBUF_CONSTEXPR DeleteWorkerSessionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
957 
958   DeleteWorkerSessionResponse(const DeleteWorkerSessionResponse& from);
DeleteWorkerSessionResponse(DeleteWorkerSessionResponse && from)959   DeleteWorkerSessionResponse(DeleteWorkerSessionResponse&& from) noexcept
960     : DeleteWorkerSessionResponse() {
961     *this = ::std::move(from);
962   }
963 
964   inline DeleteWorkerSessionResponse& operator=(const DeleteWorkerSessionResponse& from) {
965     if (this == &from) return *this;
966     CopyFrom(from);
967     return *this;
968   }
969   inline DeleteWorkerSessionResponse& operator=(DeleteWorkerSessionResponse&& from) noexcept {
970     if (this == &from) return *this;
971     if (GetOwningArena() == from.GetOwningArena()
972   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
973         && GetOwningArena() != nullptr
974   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
975     ) {
976       InternalSwap(&from);
977     } else {
978       CopyFrom(from);
979     }
980     return *this;
981   }
982 
default_instance()983   static const DeleteWorkerSessionResponse& default_instance() {
984     return *internal_default_instance();
985   }
internal_default_instance()986   static inline const DeleteWorkerSessionResponse* internal_default_instance() {
987     return reinterpret_cast<const DeleteWorkerSessionResponse*>(
988                &_DeleteWorkerSessionResponse_default_instance_);
989   }
990   static constexpr int kIndexInFileMessages =
991     5;
992 
swap(DeleteWorkerSessionResponse & a,DeleteWorkerSessionResponse & b)993   friend void swap(DeleteWorkerSessionResponse& a, DeleteWorkerSessionResponse& b) {
994     a.Swap(&b);
995   }
Swap(DeleteWorkerSessionResponse * other)996   inline void Swap(DeleteWorkerSessionResponse* other) {
997     if (other == this) return;
998   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
999     if (GetOwningArena() != nullptr &&
1000         GetOwningArena() == other->GetOwningArena()) {
1001    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1002     if (GetOwningArena() == other->GetOwningArena()) {
1003   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1004       InternalSwap(other);
1005     } else {
1006       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1007     }
1008   }
1009   void UnsafeArenaSwap(DeleteWorkerSessionResponse* other) {
1010     if (other == this) return;
1011     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1012     InternalSwap(other);
1013   }
1014 
1015   // implements Message ----------------------------------------------
1016 
1017   DeleteWorkerSessionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1018     return CreateMaybeMessage<DeleteWorkerSessionResponse>(arena);
1019   }
1020   DeleteWorkerSessionResponse* New() const {
1021     return New(nullptr);
1022   }
1023   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1024   void CopyFrom(const DeleteWorkerSessionResponse& from);
1025   void MergeFrom(const DeleteWorkerSessionResponse& from);
1026   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1027   bool IsInitialized() const final;
1028 
1029   size_t ByteSizeLong() const final;
1030   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1031   ::uint8_t* _InternalSerialize(
1032       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1033   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1034 
1035   private:
1036   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1037   void SharedDtor();
1038   void SetCachedSize(int size) const;
1039   void InternalSwap(DeleteWorkerSessionResponse* other);
1040 
1041   private:
1042   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1043   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1044     return "tensorflow.DeleteWorkerSessionResponse";
1045   }
1046   protected:
1047   explicit DeleteWorkerSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1048                        bool is_message_owned = false);
1049   public:
1050 
1051   std::string GetTypeName() const final;
1052 
1053   // nested types ----------------------------------------------------
1054 
1055   // accessors -------------------------------------------------------
1056 
1057   // @@protoc_insertion_point(class_scope:tensorflow.DeleteWorkerSessionResponse)
1058  private:
1059   class _Internal;
1060 
1061   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1062   typedef void InternalArenaConstructable_;
1063   typedef void DestructorSkippable_;
1064   struct Impl_ {
1065     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1066   };
1067   union { Impl_ _impl_; };
1068   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
1069 };
1070 // -------------------------------------------------------------------
1071 
1072 class RegisterGraphRequest final :
1073     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RegisterGraphRequest) */ {
1074  public:
RegisterGraphRequest()1075   inline RegisterGraphRequest() : RegisterGraphRequest(nullptr) {}
1076   ~RegisterGraphRequest() override;
1077   explicit PROTOBUF_CONSTEXPR RegisterGraphRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1078 
1079   RegisterGraphRequest(const RegisterGraphRequest& from);
RegisterGraphRequest(RegisterGraphRequest && from)1080   RegisterGraphRequest(RegisterGraphRequest&& from) noexcept
1081     : RegisterGraphRequest() {
1082     *this = ::std::move(from);
1083   }
1084 
1085   inline RegisterGraphRequest& operator=(const RegisterGraphRequest& from) {
1086     if (this == &from) return *this;
1087     CopyFrom(from);
1088     return *this;
1089   }
1090   inline RegisterGraphRequest& operator=(RegisterGraphRequest&& from) noexcept {
1091     if (this == &from) return *this;
1092     if (GetOwningArena() == from.GetOwningArena()
1093   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1094         && GetOwningArena() != nullptr
1095   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1096     ) {
1097       InternalSwap(&from);
1098     } else {
1099       CopyFrom(from);
1100     }
1101     return *this;
1102   }
1103 
default_instance()1104   static const RegisterGraphRequest& default_instance() {
1105     return *internal_default_instance();
1106   }
internal_default_instance()1107   static inline const RegisterGraphRequest* internal_default_instance() {
1108     return reinterpret_cast<const RegisterGraphRequest*>(
1109                &_RegisterGraphRequest_default_instance_);
1110   }
1111   static constexpr int kIndexInFileMessages =
1112     6;
1113 
swap(RegisterGraphRequest & a,RegisterGraphRequest & b)1114   friend void swap(RegisterGraphRequest& a, RegisterGraphRequest& b) {
1115     a.Swap(&b);
1116   }
Swap(RegisterGraphRequest * other)1117   inline void Swap(RegisterGraphRequest* other) {
1118     if (other == this) return;
1119   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1120     if (GetOwningArena() != nullptr &&
1121         GetOwningArena() == other->GetOwningArena()) {
1122    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1123     if (GetOwningArena() == other->GetOwningArena()) {
1124   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1125       InternalSwap(other);
1126     } else {
1127       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1128     }
1129   }
1130   void UnsafeArenaSwap(RegisterGraphRequest* other) {
1131     if (other == this) return;
1132     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1133     InternalSwap(other);
1134   }
1135 
1136   // implements Message ----------------------------------------------
1137 
1138   RegisterGraphRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1139     return CreateMaybeMessage<RegisterGraphRequest>(arena);
1140   }
1141   RegisterGraphRequest* New() const {
1142     return New(nullptr);
1143   }
1144   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1145   void CopyFrom(const RegisterGraphRequest& from);
1146   void MergeFrom(const RegisterGraphRequest& from);
1147   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1148   bool IsInitialized() const final;
1149 
1150   size_t ByteSizeLong() const final;
1151   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1152   ::uint8_t* _InternalSerialize(
1153       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1154   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1155 
1156   private:
1157   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1158   void SharedDtor();
1159   void SetCachedSize(int size) const;
1160   void InternalSwap(RegisterGraphRequest* other);
1161 
1162   private:
1163   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1164   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1165     return "tensorflow.RegisterGraphRequest";
1166   }
1167   protected:
1168   explicit RegisterGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1169                        bool is_message_owned = false);
1170   public:
1171 
1172   std::string GetTypeName() const final;
1173 
1174   // nested types ----------------------------------------------------
1175 
1176   // accessors -------------------------------------------------------
1177 
1178   enum : int {
1179     kSessionHandleFieldNumber = 1,
1180     kGraphDefFieldNumber = 2,
1181     kGraphOptionsFieldNumber = 4,
1182     kDebugOptionsFieldNumber = 5,
1183     kConfigProtoFieldNumber = 8,
1184     kCollectiveGraphKeyFieldNumber = 7,
1185     kCreateWorkerSessionCalledFieldNumber = 6,
1186     kHasControlFlowFieldNumber = 3,
1187   };
1188   // string session_handle = 1;
1189   void clear_session_handle();
1190   const std::string& session_handle() const;
1191   template <typename ArgT0 = const std::string&, typename... ArgT>
1192   void set_session_handle(ArgT0&& arg0, ArgT... args);
1193   std::string* mutable_session_handle();
1194   PROTOBUF_NODISCARD std::string* release_session_handle();
1195   void set_allocated_session_handle(std::string* session_handle);
1196   private:
1197   const std::string& _internal_session_handle() const;
1198   inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
1199   std::string* _internal_mutable_session_handle();
1200   public:
1201 
1202   // .tensorflow.GraphDef graph_def = 2;
1203   bool has_graph_def() const;
1204   private:
1205   bool _internal_has_graph_def() const;
1206   public:
1207   void clear_graph_def();
1208   const ::tensorflow::GraphDef& graph_def() const;
1209   PROTOBUF_NODISCARD ::tensorflow::GraphDef* release_graph_def();
1210   ::tensorflow::GraphDef* mutable_graph_def();
1211   void set_allocated_graph_def(::tensorflow::GraphDef* graph_def);
1212   private:
1213   const ::tensorflow::GraphDef& _internal_graph_def() const;
1214   ::tensorflow::GraphDef* _internal_mutable_graph_def();
1215   public:
1216   void unsafe_arena_set_allocated_graph_def(
1217       ::tensorflow::GraphDef* graph_def);
1218   ::tensorflow::GraphDef* unsafe_arena_release_graph_def();
1219 
1220   // .tensorflow.GraphOptions graph_options = 4;
1221   bool has_graph_options() const;
1222   private:
1223   bool _internal_has_graph_options() const;
1224   public:
1225   void clear_graph_options();
1226   const ::tensorflow::GraphOptions& graph_options() const;
1227   PROTOBUF_NODISCARD ::tensorflow::GraphOptions* release_graph_options();
1228   ::tensorflow::GraphOptions* mutable_graph_options();
1229   void set_allocated_graph_options(::tensorflow::GraphOptions* graph_options);
1230   private:
1231   const ::tensorflow::GraphOptions& _internal_graph_options() const;
1232   ::tensorflow::GraphOptions* _internal_mutable_graph_options();
1233   public:
1234   void unsafe_arena_set_allocated_graph_options(
1235       ::tensorflow::GraphOptions* graph_options);
1236   ::tensorflow::GraphOptions* unsafe_arena_release_graph_options();
1237 
1238   // .tensorflow.DebugOptions debug_options = 5;
1239   bool has_debug_options() const;
1240   private:
1241   bool _internal_has_debug_options() const;
1242   public:
1243   void clear_debug_options();
1244   const ::tensorflow::DebugOptions& debug_options() const;
1245   PROTOBUF_NODISCARD ::tensorflow::DebugOptions* release_debug_options();
1246   ::tensorflow::DebugOptions* mutable_debug_options();
1247   void set_allocated_debug_options(::tensorflow::DebugOptions* debug_options);
1248   private:
1249   const ::tensorflow::DebugOptions& _internal_debug_options() const;
1250   ::tensorflow::DebugOptions* _internal_mutable_debug_options();
1251   public:
1252   void unsafe_arena_set_allocated_debug_options(
1253       ::tensorflow::DebugOptions* debug_options);
1254   ::tensorflow::DebugOptions* unsafe_arena_release_debug_options();
1255 
1256   // .tensorflow.ConfigProto config_proto = 8;
1257   bool has_config_proto() const;
1258   private:
1259   bool _internal_has_config_proto() const;
1260   public:
1261   void clear_config_proto();
1262   const ::tensorflow::ConfigProto& config_proto() const;
1263   PROTOBUF_NODISCARD ::tensorflow::ConfigProto* release_config_proto();
1264   ::tensorflow::ConfigProto* mutable_config_proto();
1265   void set_allocated_config_proto(::tensorflow::ConfigProto* config_proto);
1266   private:
1267   const ::tensorflow::ConfigProto& _internal_config_proto() const;
1268   ::tensorflow::ConfigProto* _internal_mutable_config_proto();
1269   public:
1270   void unsafe_arena_set_allocated_config_proto(
1271       ::tensorflow::ConfigProto* config_proto);
1272   ::tensorflow::ConfigProto* unsafe_arena_release_config_proto();
1273 
1274   // int64 collective_graph_key = 7;
1275   void clear_collective_graph_key();
1276   ::int64_t collective_graph_key() const;
1277   void set_collective_graph_key(::int64_t value);
1278   private:
1279   ::int64_t _internal_collective_graph_key() const;
1280   void _internal_set_collective_graph_key(::int64_t value);
1281   public:
1282 
1283   // bool create_worker_session_called = 6;
1284   void clear_create_worker_session_called();
1285   bool create_worker_session_called() const;
1286   void set_create_worker_session_called(bool value);
1287   private:
1288   bool _internal_create_worker_session_called() const;
1289   void _internal_set_create_worker_session_called(bool value);
1290   public:
1291 
1292   // bool has_control_flow = 3 [deprecated = true];
1293   PROTOBUF_DEPRECATED void clear_has_control_flow();
1294   PROTOBUF_DEPRECATED bool has_control_flow() const;
1295   PROTOBUF_DEPRECATED void set_has_control_flow(bool value);
1296   private:
1297   bool _internal_has_control_flow() const;
1298   void _internal_set_has_control_flow(bool value);
1299   public:
1300 
1301   // @@protoc_insertion_point(class_scope:tensorflow.RegisterGraphRequest)
1302  private:
1303   class _Internal;
1304 
1305   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1306   typedef void InternalArenaConstructable_;
1307   typedef void DestructorSkippable_;
1308   struct Impl_ {
1309     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
1310     ::tensorflow::GraphDef* graph_def_;
1311     ::tensorflow::GraphOptions* graph_options_;
1312     ::tensorflow::DebugOptions* debug_options_;
1313     ::tensorflow::ConfigProto* config_proto_;
1314     ::int64_t collective_graph_key_;
1315     bool create_worker_session_called_;
1316     bool has_control_flow_;
1317     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1318   };
1319   union { Impl_ _impl_; };
1320   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
1321 };
1322 // -------------------------------------------------------------------
1323 
1324 class RegisterGraphResponse final :
1325     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RegisterGraphResponse) */ {
1326  public:
RegisterGraphResponse()1327   inline RegisterGraphResponse() : RegisterGraphResponse(nullptr) {}
1328   ~RegisterGraphResponse() override;
1329   explicit PROTOBUF_CONSTEXPR RegisterGraphResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1330 
1331   RegisterGraphResponse(const RegisterGraphResponse& from);
RegisterGraphResponse(RegisterGraphResponse && from)1332   RegisterGraphResponse(RegisterGraphResponse&& from) noexcept
1333     : RegisterGraphResponse() {
1334     *this = ::std::move(from);
1335   }
1336 
1337   inline RegisterGraphResponse& operator=(const RegisterGraphResponse& from) {
1338     if (this == &from) return *this;
1339     CopyFrom(from);
1340     return *this;
1341   }
1342   inline RegisterGraphResponse& operator=(RegisterGraphResponse&& from) noexcept {
1343     if (this == &from) return *this;
1344     if (GetOwningArena() == from.GetOwningArena()
1345   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1346         && GetOwningArena() != nullptr
1347   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1348     ) {
1349       InternalSwap(&from);
1350     } else {
1351       CopyFrom(from);
1352     }
1353     return *this;
1354   }
1355 
default_instance()1356   static const RegisterGraphResponse& default_instance() {
1357     return *internal_default_instance();
1358   }
internal_default_instance()1359   static inline const RegisterGraphResponse* internal_default_instance() {
1360     return reinterpret_cast<const RegisterGraphResponse*>(
1361                &_RegisterGraphResponse_default_instance_);
1362   }
1363   static constexpr int kIndexInFileMessages =
1364     7;
1365 
swap(RegisterGraphResponse & a,RegisterGraphResponse & b)1366   friend void swap(RegisterGraphResponse& a, RegisterGraphResponse& b) {
1367     a.Swap(&b);
1368   }
Swap(RegisterGraphResponse * other)1369   inline void Swap(RegisterGraphResponse* other) {
1370     if (other == this) return;
1371   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1372     if (GetOwningArena() != nullptr &&
1373         GetOwningArena() == other->GetOwningArena()) {
1374    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1375     if (GetOwningArena() == other->GetOwningArena()) {
1376   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1377       InternalSwap(other);
1378     } else {
1379       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1380     }
1381   }
1382   void UnsafeArenaSwap(RegisterGraphResponse* other) {
1383     if (other == this) return;
1384     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1385     InternalSwap(other);
1386   }
1387 
1388   // implements Message ----------------------------------------------
1389 
1390   RegisterGraphResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1391     return CreateMaybeMessage<RegisterGraphResponse>(arena);
1392   }
1393   RegisterGraphResponse* New() const {
1394     return New(nullptr);
1395   }
1396   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1397   void CopyFrom(const RegisterGraphResponse& from);
1398   void MergeFrom(const RegisterGraphResponse& from);
1399   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1400   bool IsInitialized() const final;
1401 
1402   size_t ByteSizeLong() const final;
1403   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1404   ::uint8_t* _InternalSerialize(
1405       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1406   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1407 
1408   private:
1409   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1410   void SharedDtor();
1411   void SetCachedSize(int size) const;
1412   void InternalSwap(RegisterGraphResponse* other);
1413 
1414   private:
1415   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1416   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1417     return "tensorflow.RegisterGraphResponse";
1418   }
1419   protected:
1420   explicit RegisterGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1421                        bool is_message_owned = false);
1422   public:
1423 
1424   std::string GetTypeName() const final;
1425 
1426   // nested types ----------------------------------------------------
1427 
1428   // accessors -------------------------------------------------------
1429 
1430   enum : int {
1431     kGraphHandleFieldNumber = 1,
1432   };
1433   // string graph_handle = 1;
1434   void clear_graph_handle();
1435   const std::string& graph_handle() const;
1436   template <typename ArgT0 = const std::string&, typename... ArgT>
1437   void set_graph_handle(ArgT0&& arg0, ArgT... args);
1438   std::string* mutable_graph_handle();
1439   PROTOBUF_NODISCARD std::string* release_graph_handle();
1440   void set_allocated_graph_handle(std::string* graph_handle);
1441   private:
1442   const std::string& _internal_graph_handle() const;
1443   inline PROTOBUF_ALWAYS_INLINE void _internal_set_graph_handle(const std::string& value);
1444   std::string* _internal_mutable_graph_handle();
1445   public:
1446 
1447   // @@protoc_insertion_point(class_scope:tensorflow.RegisterGraphResponse)
1448  private:
1449   class _Internal;
1450 
1451   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1452   typedef void InternalArenaConstructable_;
1453   typedef void DestructorSkippable_;
1454   struct Impl_ {
1455     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_handle_;
1456     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1457   };
1458   union { Impl_ _impl_; };
1459   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
1460 };
1461 // -------------------------------------------------------------------
1462 
1463 class DeregisterGraphRequest final :
1464     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DeregisterGraphRequest) */ {
1465  public:
DeregisterGraphRequest()1466   inline DeregisterGraphRequest() : DeregisterGraphRequest(nullptr) {}
1467   ~DeregisterGraphRequest() override;
1468   explicit PROTOBUF_CONSTEXPR DeregisterGraphRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1469 
1470   DeregisterGraphRequest(const DeregisterGraphRequest& from);
DeregisterGraphRequest(DeregisterGraphRequest && from)1471   DeregisterGraphRequest(DeregisterGraphRequest&& from) noexcept
1472     : DeregisterGraphRequest() {
1473     *this = ::std::move(from);
1474   }
1475 
1476   inline DeregisterGraphRequest& operator=(const DeregisterGraphRequest& from) {
1477     if (this == &from) return *this;
1478     CopyFrom(from);
1479     return *this;
1480   }
1481   inline DeregisterGraphRequest& operator=(DeregisterGraphRequest&& from) noexcept {
1482     if (this == &from) return *this;
1483     if (GetOwningArena() == from.GetOwningArena()
1484   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1485         && GetOwningArena() != nullptr
1486   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1487     ) {
1488       InternalSwap(&from);
1489     } else {
1490       CopyFrom(from);
1491     }
1492     return *this;
1493   }
1494 
default_instance()1495   static const DeregisterGraphRequest& default_instance() {
1496     return *internal_default_instance();
1497   }
internal_default_instance()1498   static inline const DeregisterGraphRequest* internal_default_instance() {
1499     return reinterpret_cast<const DeregisterGraphRequest*>(
1500                &_DeregisterGraphRequest_default_instance_);
1501   }
1502   static constexpr int kIndexInFileMessages =
1503     8;
1504 
swap(DeregisterGraphRequest & a,DeregisterGraphRequest & b)1505   friend void swap(DeregisterGraphRequest& a, DeregisterGraphRequest& b) {
1506     a.Swap(&b);
1507   }
Swap(DeregisterGraphRequest * other)1508   inline void Swap(DeregisterGraphRequest* other) {
1509     if (other == this) return;
1510   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1511     if (GetOwningArena() != nullptr &&
1512         GetOwningArena() == other->GetOwningArena()) {
1513    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1514     if (GetOwningArena() == other->GetOwningArena()) {
1515   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1516       InternalSwap(other);
1517     } else {
1518       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1519     }
1520   }
1521   void UnsafeArenaSwap(DeregisterGraphRequest* other) {
1522     if (other == this) return;
1523     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1524     InternalSwap(other);
1525   }
1526 
1527   // implements Message ----------------------------------------------
1528 
1529   DeregisterGraphRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1530     return CreateMaybeMessage<DeregisterGraphRequest>(arena);
1531   }
1532   DeregisterGraphRequest* New() const {
1533     return New(nullptr);
1534   }
1535   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1536   void CopyFrom(const DeregisterGraphRequest& from);
1537   void MergeFrom(const DeregisterGraphRequest& from);
1538   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1539   bool IsInitialized() const final;
1540 
1541   size_t ByteSizeLong() const final;
1542   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1543   ::uint8_t* _InternalSerialize(
1544       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1545   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1546 
1547   private:
1548   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1549   void SharedDtor();
1550   void SetCachedSize(int size) const;
1551   void InternalSwap(DeregisterGraphRequest* other);
1552 
1553   private:
1554   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1555   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1556     return "tensorflow.DeregisterGraphRequest";
1557   }
1558   protected:
1559   explicit DeregisterGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1560                        bool is_message_owned = false);
1561   public:
1562 
1563   std::string GetTypeName() const final;
1564 
1565   // nested types ----------------------------------------------------
1566 
1567   // accessors -------------------------------------------------------
1568 
1569   enum : int {
1570     kGraphHandleFieldNumber = 1,
1571     kSessionHandleFieldNumber = 2,
1572     kCreateWorkerSessionCalledFieldNumber = 3,
1573   };
1574   // string graph_handle = 1;
1575   void clear_graph_handle();
1576   const std::string& graph_handle() const;
1577   template <typename ArgT0 = const std::string&, typename... ArgT>
1578   void set_graph_handle(ArgT0&& arg0, ArgT... args);
1579   std::string* mutable_graph_handle();
1580   PROTOBUF_NODISCARD std::string* release_graph_handle();
1581   void set_allocated_graph_handle(std::string* graph_handle);
1582   private:
1583   const std::string& _internal_graph_handle() const;
1584   inline PROTOBUF_ALWAYS_INLINE void _internal_set_graph_handle(const std::string& value);
1585   std::string* _internal_mutable_graph_handle();
1586   public:
1587 
1588   // string session_handle = 2;
1589   void clear_session_handle();
1590   const std::string& session_handle() const;
1591   template <typename ArgT0 = const std::string&, typename... ArgT>
1592   void set_session_handle(ArgT0&& arg0, ArgT... args);
1593   std::string* mutable_session_handle();
1594   PROTOBUF_NODISCARD std::string* release_session_handle();
1595   void set_allocated_session_handle(std::string* session_handle);
1596   private:
1597   const std::string& _internal_session_handle() const;
1598   inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
1599   std::string* _internal_mutable_session_handle();
1600   public:
1601 
1602   // bool create_worker_session_called = 3;
1603   void clear_create_worker_session_called();
1604   bool create_worker_session_called() const;
1605   void set_create_worker_session_called(bool value);
1606   private:
1607   bool _internal_create_worker_session_called() const;
1608   void _internal_set_create_worker_session_called(bool value);
1609   public:
1610 
1611   // @@protoc_insertion_point(class_scope:tensorflow.DeregisterGraphRequest)
1612  private:
1613   class _Internal;
1614 
1615   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1616   typedef void InternalArenaConstructable_;
1617   typedef void DestructorSkippable_;
1618   struct Impl_ {
1619     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_handle_;
1620     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
1621     bool create_worker_session_called_;
1622     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1623   };
1624   union { Impl_ _impl_; };
1625   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
1626 };
1627 // -------------------------------------------------------------------
1628 
1629 class DeregisterGraphResponse final :
1630     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DeregisterGraphResponse) */ {
1631  public:
DeregisterGraphResponse()1632   inline DeregisterGraphResponse() : DeregisterGraphResponse(nullptr) {}
1633   ~DeregisterGraphResponse() override;
1634   explicit PROTOBUF_CONSTEXPR DeregisterGraphResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1635 
1636   DeregisterGraphResponse(const DeregisterGraphResponse& from);
DeregisterGraphResponse(DeregisterGraphResponse && from)1637   DeregisterGraphResponse(DeregisterGraphResponse&& from) noexcept
1638     : DeregisterGraphResponse() {
1639     *this = ::std::move(from);
1640   }
1641 
1642   inline DeregisterGraphResponse& operator=(const DeregisterGraphResponse& from) {
1643     if (this == &from) return *this;
1644     CopyFrom(from);
1645     return *this;
1646   }
1647   inline DeregisterGraphResponse& operator=(DeregisterGraphResponse&& from) noexcept {
1648     if (this == &from) return *this;
1649     if (GetOwningArena() == from.GetOwningArena()
1650   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1651         && GetOwningArena() != nullptr
1652   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1653     ) {
1654       InternalSwap(&from);
1655     } else {
1656       CopyFrom(from);
1657     }
1658     return *this;
1659   }
1660 
default_instance()1661   static const DeregisterGraphResponse& default_instance() {
1662     return *internal_default_instance();
1663   }
internal_default_instance()1664   static inline const DeregisterGraphResponse* internal_default_instance() {
1665     return reinterpret_cast<const DeregisterGraphResponse*>(
1666                &_DeregisterGraphResponse_default_instance_);
1667   }
1668   static constexpr int kIndexInFileMessages =
1669     9;
1670 
swap(DeregisterGraphResponse & a,DeregisterGraphResponse & b)1671   friend void swap(DeregisterGraphResponse& a, DeregisterGraphResponse& b) {
1672     a.Swap(&b);
1673   }
Swap(DeregisterGraphResponse * other)1674   inline void Swap(DeregisterGraphResponse* other) {
1675     if (other == this) return;
1676   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1677     if (GetOwningArena() != nullptr &&
1678         GetOwningArena() == other->GetOwningArena()) {
1679    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1680     if (GetOwningArena() == other->GetOwningArena()) {
1681   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1682       InternalSwap(other);
1683     } else {
1684       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1685     }
1686   }
1687   void UnsafeArenaSwap(DeregisterGraphResponse* other) {
1688     if (other == this) return;
1689     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1690     InternalSwap(other);
1691   }
1692 
1693   // implements Message ----------------------------------------------
1694 
1695   DeregisterGraphResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1696     return CreateMaybeMessage<DeregisterGraphResponse>(arena);
1697   }
1698   DeregisterGraphResponse* New() const {
1699     return New(nullptr);
1700   }
1701   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1702   void CopyFrom(const DeregisterGraphResponse& from);
1703   void MergeFrom(const DeregisterGraphResponse& from);
1704   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1705   bool IsInitialized() const final;
1706 
1707   size_t ByteSizeLong() const final;
1708   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1709   ::uint8_t* _InternalSerialize(
1710       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1711   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1712 
1713   private:
1714   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1715   void SharedDtor();
1716   void SetCachedSize(int size) const;
1717   void InternalSwap(DeregisterGraphResponse* other);
1718 
1719   private:
1720   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1721   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1722     return "tensorflow.DeregisterGraphResponse";
1723   }
1724   protected:
1725   explicit DeregisterGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1726                        bool is_message_owned = false);
1727   public:
1728 
1729   std::string GetTypeName() const final;
1730 
1731   // nested types ----------------------------------------------------
1732 
1733   // accessors -------------------------------------------------------
1734 
1735   // @@protoc_insertion_point(class_scope:tensorflow.DeregisterGraphResponse)
1736  private:
1737   class _Internal;
1738 
1739   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1740   typedef void InternalArenaConstructable_;
1741   typedef void DestructorSkippable_;
1742   struct Impl_ {
1743     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1744   };
1745   union { Impl_ _impl_; };
1746   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
1747 };
1748 // -------------------------------------------------------------------
1749 
1750 class CleanupAllRequest final :
1751     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CleanupAllRequest) */ {
1752  public:
CleanupAllRequest()1753   inline CleanupAllRequest() : CleanupAllRequest(nullptr) {}
1754   ~CleanupAllRequest() override;
1755   explicit PROTOBUF_CONSTEXPR CleanupAllRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1756 
1757   CleanupAllRequest(const CleanupAllRequest& from);
CleanupAllRequest(CleanupAllRequest && from)1758   CleanupAllRequest(CleanupAllRequest&& from) noexcept
1759     : CleanupAllRequest() {
1760     *this = ::std::move(from);
1761   }
1762 
1763   inline CleanupAllRequest& operator=(const CleanupAllRequest& from) {
1764     if (this == &from) return *this;
1765     CopyFrom(from);
1766     return *this;
1767   }
1768   inline CleanupAllRequest& operator=(CleanupAllRequest&& from) noexcept {
1769     if (this == &from) return *this;
1770     if (GetOwningArena() == from.GetOwningArena()
1771   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1772         && GetOwningArena() != nullptr
1773   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1774     ) {
1775       InternalSwap(&from);
1776     } else {
1777       CopyFrom(from);
1778     }
1779     return *this;
1780   }
1781 
default_instance()1782   static const CleanupAllRequest& default_instance() {
1783     return *internal_default_instance();
1784   }
internal_default_instance()1785   static inline const CleanupAllRequest* internal_default_instance() {
1786     return reinterpret_cast<const CleanupAllRequest*>(
1787                &_CleanupAllRequest_default_instance_);
1788   }
1789   static constexpr int kIndexInFileMessages =
1790     10;
1791 
swap(CleanupAllRequest & a,CleanupAllRequest & b)1792   friend void swap(CleanupAllRequest& a, CleanupAllRequest& b) {
1793     a.Swap(&b);
1794   }
Swap(CleanupAllRequest * other)1795   inline void Swap(CleanupAllRequest* other) {
1796     if (other == this) return;
1797   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1798     if (GetOwningArena() != nullptr &&
1799         GetOwningArena() == other->GetOwningArena()) {
1800    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1801     if (GetOwningArena() == other->GetOwningArena()) {
1802   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1803       InternalSwap(other);
1804     } else {
1805       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1806     }
1807   }
1808   void UnsafeArenaSwap(CleanupAllRequest* other) {
1809     if (other == this) return;
1810     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1811     InternalSwap(other);
1812   }
1813 
1814   // implements Message ----------------------------------------------
1815 
1816   CleanupAllRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1817     return CreateMaybeMessage<CleanupAllRequest>(arena);
1818   }
1819   CleanupAllRequest* New() const {
1820     return New(nullptr);
1821   }
1822   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1823   void CopyFrom(const CleanupAllRequest& from);
1824   void MergeFrom(const CleanupAllRequest& from);
1825   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1826   bool IsInitialized() const final;
1827 
1828   size_t ByteSizeLong() const final;
1829   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1830   ::uint8_t* _InternalSerialize(
1831       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1832   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1833 
1834   private:
1835   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1836   void SharedDtor();
1837   void SetCachedSize(int size) const;
1838   void InternalSwap(CleanupAllRequest* other);
1839 
1840   private:
1841   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1842   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1843     return "tensorflow.CleanupAllRequest";
1844   }
1845   protected:
1846   explicit CleanupAllRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1847                        bool is_message_owned = false);
1848   public:
1849 
1850   std::string GetTypeName() const final;
1851 
1852   // nested types ----------------------------------------------------
1853 
1854   // accessors -------------------------------------------------------
1855 
1856   enum : int {
1857     kContainerFieldNumber = 1,
1858   };
1859   // repeated string container = 1;
1860   int container_size() const;
1861   private:
1862   int _internal_container_size() const;
1863   public:
1864   void clear_container();
1865   const std::string& container(int index) const;
1866   std::string* mutable_container(int index);
1867   void set_container(int index, const std::string& value);
1868   void set_container(int index, std::string&& value);
1869   void set_container(int index, const char* value);
1870   void set_container(int index, const char* value, size_t size);
1871   std::string* add_container();
1872   void add_container(const std::string& value);
1873   void add_container(std::string&& value);
1874   void add_container(const char* value);
1875   void add_container(const char* value, size_t size);
1876   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& container() const;
1877   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_container();
1878   private:
1879   const std::string& _internal_container(int index) const;
1880   std::string* _internal_add_container();
1881   public:
1882 
1883   // @@protoc_insertion_point(class_scope:tensorflow.CleanupAllRequest)
1884  private:
1885   class _Internal;
1886 
1887   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1888   typedef void InternalArenaConstructable_;
1889   typedef void DestructorSkippable_;
1890   struct Impl_ {
1891     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> container_;
1892     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1893   };
1894   union { Impl_ _impl_; };
1895   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
1896 };
1897 // -------------------------------------------------------------------
1898 
1899 class CleanupAllResponse final :
1900     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CleanupAllResponse) */ {
1901  public:
CleanupAllResponse()1902   inline CleanupAllResponse() : CleanupAllResponse(nullptr) {}
1903   ~CleanupAllResponse() override;
1904   explicit PROTOBUF_CONSTEXPR CleanupAllResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1905 
1906   CleanupAllResponse(const CleanupAllResponse& from);
CleanupAllResponse(CleanupAllResponse && from)1907   CleanupAllResponse(CleanupAllResponse&& from) noexcept
1908     : CleanupAllResponse() {
1909     *this = ::std::move(from);
1910   }
1911 
1912   inline CleanupAllResponse& operator=(const CleanupAllResponse& from) {
1913     if (this == &from) return *this;
1914     CopyFrom(from);
1915     return *this;
1916   }
1917   inline CleanupAllResponse& operator=(CleanupAllResponse&& from) noexcept {
1918     if (this == &from) return *this;
1919     if (GetOwningArena() == from.GetOwningArena()
1920   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1921         && GetOwningArena() != nullptr
1922   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
1923     ) {
1924       InternalSwap(&from);
1925     } else {
1926       CopyFrom(from);
1927     }
1928     return *this;
1929   }
1930 
default_instance()1931   static const CleanupAllResponse& default_instance() {
1932     return *internal_default_instance();
1933   }
internal_default_instance()1934   static inline const CleanupAllResponse* internal_default_instance() {
1935     return reinterpret_cast<const CleanupAllResponse*>(
1936                &_CleanupAllResponse_default_instance_);
1937   }
1938   static constexpr int kIndexInFileMessages =
1939     11;
1940 
swap(CleanupAllResponse & a,CleanupAllResponse & b)1941   friend void swap(CleanupAllResponse& a, CleanupAllResponse& b) {
1942     a.Swap(&b);
1943   }
Swap(CleanupAllResponse * other)1944   inline void Swap(CleanupAllResponse* other) {
1945     if (other == this) return;
1946   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1947     if (GetOwningArena() != nullptr &&
1948         GetOwningArena() == other->GetOwningArena()) {
1949    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
1950     if (GetOwningArena() == other->GetOwningArena()) {
1951   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
1952       InternalSwap(other);
1953     } else {
1954       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1955     }
1956   }
1957   void UnsafeArenaSwap(CleanupAllResponse* other) {
1958     if (other == this) return;
1959     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1960     InternalSwap(other);
1961   }
1962 
1963   // implements Message ----------------------------------------------
1964 
1965   CleanupAllResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1966     return CreateMaybeMessage<CleanupAllResponse>(arena);
1967   }
1968   CleanupAllResponse* New() const {
1969     return New(nullptr);
1970   }
1971   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
1972   void CopyFrom(const CleanupAllResponse& from);
1973   void MergeFrom(const CleanupAllResponse& from);
1974   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1975   bool IsInitialized() const final;
1976 
1977   size_t ByteSizeLong() const final;
1978   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1979   ::uint8_t* _InternalSerialize(
1980       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1981   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1982 
1983   private:
1984   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1985   void SharedDtor();
1986   void SetCachedSize(int size) const;
1987   void InternalSwap(CleanupAllResponse* other);
1988 
1989   private:
1990   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1991   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1992     return "tensorflow.CleanupAllResponse";
1993   }
1994   protected:
1995   explicit CleanupAllResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1996                        bool is_message_owned = false);
1997   public:
1998 
1999   std::string GetTypeName() const final;
2000 
2001   // nested types ----------------------------------------------------
2002 
2003   // accessors -------------------------------------------------------
2004 
2005   // @@protoc_insertion_point(class_scope:tensorflow.CleanupAllResponse)
2006  private:
2007   class _Internal;
2008 
2009   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2010   typedef void InternalArenaConstructable_;
2011   typedef void DestructorSkippable_;
2012   struct Impl_ {
2013     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2014   };
2015   union { Impl_ _impl_; };
2016   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
2017 };
2018 // -------------------------------------------------------------------
2019 
2020 class ExecutorOpts final :
2021     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ExecutorOpts) */ {
2022  public:
ExecutorOpts()2023   inline ExecutorOpts() : ExecutorOpts(nullptr) {}
2024   ~ExecutorOpts() override;
2025   explicit PROTOBUF_CONSTEXPR ExecutorOpts(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2026 
2027   ExecutorOpts(const ExecutorOpts& from);
ExecutorOpts(ExecutorOpts && from)2028   ExecutorOpts(ExecutorOpts&& from) noexcept
2029     : ExecutorOpts() {
2030     *this = ::std::move(from);
2031   }
2032 
2033   inline ExecutorOpts& operator=(const ExecutorOpts& from) {
2034     if (this == &from) return *this;
2035     CopyFrom(from);
2036     return *this;
2037   }
2038   inline ExecutorOpts& operator=(ExecutorOpts&& from) noexcept {
2039     if (this == &from) return *this;
2040     if (GetOwningArena() == from.GetOwningArena()
2041   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2042         && GetOwningArena() != nullptr
2043   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2044     ) {
2045       InternalSwap(&from);
2046     } else {
2047       CopyFrom(from);
2048     }
2049     return *this;
2050   }
2051 
default_instance()2052   static const ExecutorOpts& default_instance() {
2053     return *internal_default_instance();
2054   }
internal_default_instance()2055   static inline const ExecutorOpts* internal_default_instance() {
2056     return reinterpret_cast<const ExecutorOpts*>(
2057                &_ExecutorOpts_default_instance_);
2058   }
2059   static constexpr int kIndexInFileMessages =
2060     12;
2061 
swap(ExecutorOpts & a,ExecutorOpts & b)2062   friend void swap(ExecutorOpts& a, ExecutorOpts& b) {
2063     a.Swap(&b);
2064   }
Swap(ExecutorOpts * other)2065   inline void Swap(ExecutorOpts* other) {
2066     if (other == this) return;
2067   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2068     if (GetOwningArena() != nullptr &&
2069         GetOwningArena() == other->GetOwningArena()) {
2070    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2071     if (GetOwningArena() == other->GetOwningArena()) {
2072   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2073       InternalSwap(other);
2074     } else {
2075       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2076     }
2077   }
2078   void UnsafeArenaSwap(ExecutorOpts* other) {
2079     if (other == this) return;
2080     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2081     InternalSwap(other);
2082   }
2083 
2084   // implements Message ----------------------------------------------
2085 
2086   ExecutorOpts* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2087     return CreateMaybeMessage<ExecutorOpts>(arena);
2088   }
2089   ExecutorOpts* New() const {
2090     return New(nullptr);
2091   }
2092   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2093   void CopyFrom(const ExecutorOpts& from);
2094   void MergeFrom(const ExecutorOpts& from);
2095   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2096   bool IsInitialized() const final;
2097 
2098   size_t ByteSizeLong() const final;
2099   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2100   ::uint8_t* _InternalSerialize(
2101       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2102   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2103 
2104   private:
2105   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2106   void SharedDtor();
2107   void SetCachedSize(int size) const;
2108   void InternalSwap(ExecutorOpts* other);
2109 
2110   private:
2111   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2112   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2113     return "tensorflow.ExecutorOpts";
2114   }
2115   protected:
2116   explicit ExecutorOpts(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2117                        bool is_message_owned = false);
2118   public:
2119 
2120   std::string GetTypeName() const final;
2121 
2122   // nested types ----------------------------------------------------
2123 
2124   // accessors -------------------------------------------------------
2125 
2126   enum : int {
2127     kRecordCostsFieldNumber = 1,
2128     kRecordTimelineFieldNumber = 3,
2129     kRecordPartitionGraphsFieldNumber = 4,
2130     kReportTensorAllocationsUponOomFieldNumber = 5,
2131   };
2132   // bool record_costs = 1;
2133   void clear_record_costs();
2134   bool record_costs() const;
2135   void set_record_costs(bool value);
2136   private:
2137   bool _internal_record_costs() const;
2138   void _internal_set_record_costs(bool value);
2139   public:
2140 
2141   // bool record_timeline = 3;
2142   void clear_record_timeline();
2143   bool record_timeline() const;
2144   void set_record_timeline(bool value);
2145   private:
2146   bool _internal_record_timeline() const;
2147   void _internal_set_record_timeline(bool value);
2148   public:
2149 
2150   // bool record_partition_graphs = 4;
2151   void clear_record_partition_graphs();
2152   bool record_partition_graphs() const;
2153   void set_record_partition_graphs(bool value);
2154   private:
2155   bool _internal_record_partition_graphs() const;
2156   void _internal_set_record_partition_graphs(bool value);
2157   public:
2158 
2159   // bool report_tensor_allocations_upon_oom = 5;
2160   void clear_report_tensor_allocations_upon_oom();
2161   bool report_tensor_allocations_upon_oom() const;
2162   void set_report_tensor_allocations_upon_oom(bool value);
2163   private:
2164   bool _internal_report_tensor_allocations_upon_oom() const;
2165   void _internal_set_report_tensor_allocations_upon_oom(bool value);
2166   public:
2167 
2168   // @@protoc_insertion_point(class_scope:tensorflow.ExecutorOpts)
2169  private:
2170   class _Internal;
2171 
2172   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2173   typedef void InternalArenaConstructable_;
2174   typedef void DestructorSkippable_;
2175   struct Impl_ {
2176     bool record_costs_;
2177     bool record_timeline_;
2178     bool record_partition_graphs_;
2179     bool report_tensor_allocations_upon_oom_;
2180     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2181   };
2182   union { Impl_ _impl_; };
2183   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
2184 };
2185 // -------------------------------------------------------------------
2186 
2187 class RunGraphRequest final :
2188     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RunGraphRequest) */ {
2189  public:
RunGraphRequest()2190   inline RunGraphRequest() : RunGraphRequest(nullptr) {}
2191   ~RunGraphRequest() override;
2192   explicit PROTOBUF_CONSTEXPR RunGraphRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2193 
2194   RunGraphRequest(const RunGraphRequest& from);
RunGraphRequest(RunGraphRequest && from)2195   RunGraphRequest(RunGraphRequest&& from) noexcept
2196     : RunGraphRequest() {
2197     *this = ::std::move(from);
2198   }
2199 
2200   inline RunGraphRequest& operator=(const RunGraphRequest& from) {
2201     if (this == &from) return *this;
2202     CopyFrom(from);
2203     return *this;
2204   }
2205   inline RunGraphRequest& operator=(RunGraphRequest&& from) noexcept {
2206     if (this == &from) return *this;
2207     if (GetOwningArena() == from.GetOwningArena()
2208   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2209         && GetOwningArena() != nullptr
2210   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2211     ) {
2212       InternalSwap(&from);
2213     } else {
2214       CopyFrom(from);
2215     }
2216     return *this;
2217   }
2218 
default_instance()2219   static const RunGraphRequest& default_instance() {
2220     return *internal_default_instance();
2221   }
internal_default_instance()2222   static inline const RunGraphRequest* internal_default_instance() {
2223     return reinterpret_cast<const RunGraphRequest*>(
2224                &_RunGraphRequest_default_instance_);
2225   }
2226   static constexpr int kIndexInFileMessages =
2227     13;
2228 
swap(RunGraphRequest & a,RunGraphRequest & b)2229   friend void swap(RunGraphRequest& a, RunGraphRequest& b) {
2230     a.Swap(&b);
2231   }
Swap(RunGraphRequest * other)2232   inline void Swap(RunGraphRequest* other) {
2233     if (other == this) return;
2234   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2235     if (GetOwningArena() != nullptr &&
2236         GetOwningArena() == other->GetOwningArena()) {
2237    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2238     if (GetOwningArena() == other->GetOwningArena()) {
2239   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2240       InternalSwap(other);
2241     } else {
2242       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2243     }
2244   }
2245   void UnsafeArenaSwap(RunGraphRequest* other) {
2246     if (other == this) return;
2247     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2248     InternalSwap(other);
2249   }
2250 
2251   // implements Message ----------------------------------------------
2252 
2253   RunGraphRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2254     return CreateMaybeMessage<RunGraphRequest>(arena);
2255   }
2256   RunGraphRequest* New() const {
2257     return New(nullptr);
2258   }
2259   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2260   void CopyFrom(const RunGraphRequest& from);
2261   void MergeFrom(const RunGraphRequest& from);
2262   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2263   bool IsInitialized() const final;
2264 
2265   size_t ByteSizeLong() const final;
2266   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2267   ::uint8_t* _InternalSerialize(
2268       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2269   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2270 
2271   private:
2272   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2273   void SharedDtor();
2274   void SetCachedSize(int size) const;
2275   void InternalSwap(RunGraphRequest* other);
2276 
2277   private:
2278   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2279   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2280     return "tensorflow.RunGraphRequest";
2281   }
2282   protected:
2283   explicit RunGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2284                        bool is_message_owned = false);
2285   public:
2286 
2287   std::string GetTypeName() const final;
2288 
2289   // nested types ----------------------------------------------------
2290 
2291   // accessors -------------------------------------------------------
2292 
2293   enum : int {
2294     kSendFieldNumber = 3,
2295     kRecvKeyFieldNumber = 4,
2296     kGraphHandleFieldNumber = 1,
2297     kSessionHandleFieldNumber = 8,
2298     kExecOptsFieldNumber = 5,
2299     kStepIdFieldNumber = 2,
2300     kRequestIdFieldNumber = 11,
2301     kCreateWorkerSessionCalledFieldNumber = 10,
2302     kIsPartialFieldNumber = 6,
2303     kIsLastPartialRunFieldNumber = 7,
2304     kStoreErrorsInResponseBodyFieldNumber = 9,
2305   };
2306   // repeated .tensorflow.NamedTensorProto send = 3;
2307   int send_size() const;
2308   private:
2309   int _internal_send_size() const;
2310   public:
2311   void clear_send();
2312   ::tensorflow::NamedTensorProto* mutable_send(int index);
2313   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
2314       mutable_send();
2315   private:
2316   const ::tensorflow::NamedTensorProto& _internal_send(int index) const;
2317   ::tensorflow::NamedTensorProto* _internal_add_send();
2318   public:
2319   const ::tensorflow::NamedTensorProto& send(int index) const;
2320   ::tensorflow::NamedTensorProto* add_send();
2321   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
2322       send() const;
2323 
2324   // repeated string recv_key = 4;
2325   int recv_key_size() const;
2326   private:
2327   int _internal_recv_key_size() const;
2328   public:
2329   void clear_recv_key();
2330   const std::string& recv_key(int index) const;
2331   std::string* mutable_recv_key(int index);
2332   void set_recv_key(int index, const std::string& value);
2333   void set_recv_key(int index, std::string&& value);
2334   void set_recv_key(int index, const char* value);
2335   void set_recv_key(int index, const char* value, size_t size);
2336   std::string* add_recv_key();
2337   void add_recv_key(const std::string& value);
2338   void add_recv_key(std::string&& value);
2339   void add_recv_key(const char* value);
2340   void add_recv_key(const char* value, size_t size);
2341   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& recv_key() const;
2342   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_recv_key();
2343   private:
2344   const std::string& _internal_recv_key(int index) const;
2345   std::string* _internal_add_recv_key();
2346   public:
2347 
2348   // string graph_handle = 1;
2349   void clear_graph_handle();
2350   const std::string& graph_handle() const;
2351   template <typename ArgT0 = const std::string&, typename... ArgT>
2352   void set_graph_handle(ArgT0&& arg0, ArgT... args);
2353   std::string* mutable_graph_handle();
2354   PROTOBUF_NODISCARD std::string* release_graph_handle();
2355   void set_allocated_graph_handle(std::string* graph_handle);
2356   private:
2357   const std::string& _internal_graph_handle() const;
2358   inline PROTOBUF_ALWAYS_INLINE void _internal_set_graph_handle(const std::string& value);
2359   std::string* _internal_mutable_graph_handle();
2360   public:
2361 
2362   // string session_handle = 8;
2363   void clear_session_handle();
2364   const std::string& session_handle() const;
2365   template <typename ArgT0 = const std::string&, typename... ArgT>
2366   void set_session_handle(ArgT0&& arg0, ArgT... args);
2367   std::string* mutable_session_handle();
2368   PROTOBUF_NODISCARD std::string* release_session_handle();
2369   void set_allocated_session_handle(std::string* session_handle);
2370   private:
2371   const std::string& _internal_session_handle() const;
2372   inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
2373   std::string* _internal_mutable_session_handle();
2374   public:
2375 
2376   // .tensorflow.ExecutorOpts exec_opts = 5;
2377   bool has_exec_opts() const;
2378   private:
2379   bool _internal_has_exec_opts() const;
2380   public:
2381   void clear_exec_opts();
2382   const ::tensorflow::ExecutorOpts& exec_opts() const;
2383   PROTOBUF_NODISCARD ::tensorflow::ExecutorOpts* release_exec_opts();
2384   ::tensorflow::ExecutorOpts* mutable_exec_opts();
2385   void set_allocated_exec_opts(::tensorflow::ExecutorOpts* exec_opts);
2386   private:
2387   const ::tensorflow::ExecutorOpts& _internal_exec_opts() const;
2388   ::tensorflow::ExecutorOpts* _internal_mutable_exec_opts();
2389   public:
2390   void unsafe_arena_set_allocated_exec_opts(
2391       ::tensorflow::ExecutorOpts* exec_opts);
2392   ::tensorflow::ExecutorOpts* unsafe_arena_release_exec_opts();
2393 
2394   // int64 step_id = 2;
2395   void clear_step_id();
2396   ::int64_t step_id() const;
2397   void set_step_id(::int64_t value);
2398   private:
2399   ::int64_t _internal_step_id() const;
2400   void _internal_set_step_id(::int64_t value);
2401   public:
2402 
2403   // int64 request_id = 11;
2404   void clear_request_id();
2405   ::int64_t request_id() const;
2406   void set_request_id(::int64_t value);
2407   private:
2408   ::int64_t _internal_request_id() const;
2409   void _internal_set_request_id(::int64_t value);
2410   public:
2411 
2412   // bool create_worker_session_called = 10;
2413   void clear_create_worker_session_called();
2414   bool create_worker_session_called() const;
2415   void set_create_worker_session_called(bool value);
2416   private:
2417   bool _internal_create_worker_session_called() const;
2418   void _internal_set_create_worker_session_called(bool value);
2419   public:
2420 
2421   // bool is_partial = 6;
2422   void clear_is_partial();
2423   bool is_partial() const;
2424   void set_is_partial(bool value);
2425   private:
2426   bool _internal_is_partial() const;
2427   void _internal_set_is_partial(bool value);
2428   public:
2429 
2430   // bool is_last_partial_run = 7;
2431   void clear_is_last_partial_run();
2432   bool is_last_partial_run() const;
2433   void set_is_last_partial_run(bool value);
2434   private:
2435   bool _internal_is_last_partial_run() const;
2436   void _internal_set_is_last_partial_run(bool value);
2437   public:
2438 
2439   // bool store_errors_in_response_body = 9;
2440   void clear_store_errors_in_response_body();
2441   bool store_errors_in_response_body() const;
2442   void set_store_errors_in_response_body(bool value);
2443   private:
2444   bool _internal_store_errors_in_response_body() const;
2445   void _internal_set_store_errors_in_response_body(bool value);
2446   public:
2447 
2448   // @@protoc_insertion_point(class_scope:tensorflow.RunGraphRequest)
2449  private:
2450   class _Internal;
2451 
2452   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2453   typedef void InternalArenaConstructable_;
2454   typedef void DestructorSkippable_;
2455   struct Impl_ {
2456     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto > send_;
2457     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> recv_key_;
2458     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_handle_;
2459     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
2460     ::tensorflow::ExecutorOpts* exec_opts_;
2461     ::int64_t step_id_;
2462     ::int64_t request_id_;
2463     bool create_worker_session_called_;
2464     bool is_partial_;
2465     bool is_last_partial_run_;
2466     bool store_errors_in_response_body_;
2467     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2468   };
2469   union { Impl_ _impl_; };
2470   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
2471 };
2472 // -------------------------------------------------------------------
2473 
2474 class RunGraphResponse final :
2475     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RunGraphResponse) */ {
2476  public:
RunGraphResponse()2477   inline RunGraphResponse() : RunGraphResponse(nullptr) {}
2478   ~RunGraphResponse() override;
2479   explicit PROTOBUF_CONSTEXPR RunGraphResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2480 
2481   RunGraphResponse(const RunGraphResponse& from);
RunGraphResponse(RunGraphResponse && from)2482   RunGraphResponse(RunGraphResponse&& from) noexcept
2483     : RunGraphResponse() {
2484     *this = ::std::move(from);
2485   }
2486 
2487   inline RunGraphResponse& operator=(const RunGraphResponse& from) {
2488     if (this == &from) return *this;
2489     CopyFrom(from);
2490     return *this;
2491   }
2492   inline RunGraphResponse& operator=(RunGraphResponse&& from) noexcept {
2493     if (this == &from) return *this;
2494     if (GetOwningArena() == from.GetOwningArena()
2495   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2496         && GetOwningArena() != nullptr
2497   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2498     ) {
2499       InternalSwap(&from);
2500     } else {
2501       CopyFrom(from);
2502     }
2503     return *this;
2504   }
2505 
default_instance()2506   static const RunGraphResponse& default_instance() {
2507     return *internal_default_instance();
2508   }
internal_default_instance()2509   static inline const RunGraphResponse* internal_default_instance() {
2510     return reinterpret_cast<const RunGraphResponse*>(
2511                &_RunGraphResponse_default_instance_);
2512   }
2513   static constexpr int kIndexInFileMessages =
2514     14;
2515 
swap(RunGraphResponse & a,RunGraphResponse & b)2516   friend void swap(RunGraphResponse& a, RunGraphResponse& b) {
2517     a.Swap(&b);
2518   }
Swap(RunGraphResponse * other)2519   inline void Swap(RunGraphResponse* other) {
2520     if (other == this) return;
2521   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2522     if (GetOwningArena() != nullptr &&
2523         GetOwningArena() == other->GetOwningArena()) {
2524    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2525     if (GetOwningArena() == other->GetOwningArena()) {
2526   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2527       InternalSwap(other);
2528     } else {
2529       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2530     }
2531   }
2532   void UnsafeArenaSwap(RunGraphResponse* other) {
2533     if (other == this) return;
2534     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2535     InternalSwap(other);
2536   }
2537 
2538   // implements Message ----------------------------------------------
2539 
2540   RunGraphResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2541     return CreateMaybeMessage<RunGraphResponse>(arena);
2542   }
2543   RunGraphResponse* New() const {
2544     return New(nullptr);
2545   }
2546   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2547   void CopyFrom(const RunGraphResponse& from);
2548   void MergeFrom(const RunGraphResponse& from);
2549   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2550   bool IsInitialized() const final;
2551 
2552   size_t ByteSizeLong() const final;
2553   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2554   ::uint8_t* _InternalSerialize(
2555       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2556   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2557 
2558   private:
2559   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2560   void SharedDtor();
2561   void SetCachedSize(int size) const;
2562   void InternalSwap(RunGraphResponse* other);
2563 
2564   private:
2565   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2566   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2567     return "tensorflow.RunGraphResponse";
2568   }
2569   protected:
2570   explicit RunGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2571                        bool is_message_owned = false);
2572   public:
2573 
2574   std::string GetTypeName() const final;
2575 
2576   // nested types ----------------------------------------------------
2577 
2578   // accessors -------------------------------------------------------
2579 
2580   enum : int {
2581     kRecvFieldNumber = 1,
2582     kPartitionGraphFieldNumber = 4,
2583     kStatusErrorMessageFieldNumber = 6,
2584     kStepStatsFieldNumber = 2,
2585     kCostGraphFieldNumber = 3,
2586     kStatusCodeFieldNumber = 5,
2587   };
2588   // repeated .tensorflow.NamedTensorProto recv = 1;
2589   int recv_size() const;
2590   private:
2591   int _internal_recv_size() const;
2592   public:
2593   void clear_recv();
2594   ::tensorflow::NamedTensorProto* mutable_recv(int index);
2595   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
2596       mutable_recv();
2597   private:
2598   const ::tensorflow::NamedTensorProto& _internal_recv(int index) const;
2599   ::tensorflow::NamedTensorProto* _internal_add_recv();
2600   public:
2601   const ::tensorflow::NamedTensorProto& recv(int index) const;
2602   ::tensorflow::NamedTensorProto* add_recv();
2603   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
2604       recv() const;
2605 
2606   // repeated .tensorflow.GraphDef partition_graph = 4;
2607   int partition_graph_size() const;
2608   private:
2609   int _internal_partition_graph_size() const;
2610   public:
2611   void clear_partition_graph();
2612   ::tensorflow::GraphDef* mutable_partition_graph(int index);
2613   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDef >*
2614       mutable_partition_graph();
2615   private:
2616   const ::tensorflow::GraphDef& _internal_partition_graph(int index) const;
2617   ::tensorflow::GraphDef* _internal_add_partition_graph();
2618   public:
2619   const ::tensorflow::GraphDef& partition_graph(int index) const;
2620   ::tensorflow::GraphDef* add_partition_graph();
2621   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDef >&
2622       partition_graph() const;
2623 
2624   // string status_error_message = 6;
2625   void clear_status_error_message();
2626   const std::string& status_error_message() const;
2627   template <typename ArgT0 = const std::string&, typename... ArgT>
2628   void set_status_error_message(ArgT0&& arg0, ArgT... args);
2629   std::string* mutable_status_error_message();
2630   PROTOBUF_NODISCARD std::string* release_status_error_message();
2631   void set_allocated_status_error_message(std::string* status_error_message);
2632   private:
2633   const std::string& _internal_status_error_message() const;
2634   inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_error_message(const std::string& value);
2635   std::string* _internal_mutable_status_error_message();
2636   public:
2637 
2638   // .tensorflow.StepStats step_stats = 2;
2639   bool has_step_stats() const;
2640   private:
2641   bool _internal_has_step_stats() const;
2642   public:
2643   void clear_step_stats();
2644   const ::tensorflow::StepStats& step_stats() const;
2645   PROTOBUF_NODISCARD ::tensorflow::StepStats* release_step_stats();
2646   ::tensorflow::StepStats* mutable_step_stats();
2647   void set_allocated_step_stats(::tensorflow::StepStats* step_stats);
2648   private:
2649   const ::tensorflow::StepStats& _internal_step_stats() const;
2650   ::tensorflow::StepStats* _internal_mutable_step_stats();
2651   public:
2652   void unsafe_arena_set_allocated_step_stats(
2653       ::tensorflow::StepStats* step_stats);
2654   ::tensorflow::StepStats* unsafe_arena_release_step_stats();
2655 
2656   // .tensorflow.CostGraphDef cost_graph = 3;
2657   bool has_cost_graph() const;
2658   private:
2659   bool _internal_has_cost_graph() const;
2660   public:
2661   void clear_cost_graph();
2662   const ::tensorflow::CostGraphDef& cost_graph() const;
2663   PROTOBUF_NODISCARD ::tensorflow::CostGraphDef* release_cost_graph();
2664   ::tensorflow::CostGraphDef* mutable_cost_graph();
2665   void set_allocated_cost_graph(::tensorflow::CostGraphDef* cost_graph);
2666   private:
2667   const ::tensorflow::CostGraphDef& _internal_cost_graph() const;
2668   ::tensorflow::CostGraphDef* _internal_mutable_cost_graph();
2669   public:
2670   void unsafe_arena_set_allocated_cost_graph(
2671       ::tensorflow::CostGraphDef* cost_graph);
2672   ::tensorflow::CostGraphDef* unsafe_arena_release_cost_graph();
2673 
2674   // .tensorflow.error.Code status_code = 5;
2675   void clear_status_code();
2676   ::tensorflow::error::Code status_code() const;
2677   void set_status_code(::tensorflow::error::Code value);
2678   private:
2679   ::tensorflow::error::Code _internal_status_code() const;
2680   void _internal_set_status_code(::tensorflow::error::Code value);
2681   public:
2682 
2683   // @@protoc_insertion_point(class_scope:tensorflow.RunGraphResponse)
2684  private:
2685   class _Internal;
2686 
2687   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2688   typedef void InternalArenaConstructable_;
2689   typedef void DestructorSkippable_;
2690   struct Impl_ {
2691     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto > recv_;
2692     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDef > partition_graph_;
2693     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_error_message_;
2694     ::tensorflow::StepStats* step_stats_;
2695     ::tensorflow::CostGraphDef* cost_graph_;
2696     int status_code_;
2697     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2698   };
2699   union { Impl_ _impl_; };
2700   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
2701 };
2702 // -------------------------------------------------------------------
2703 
2704 class CleanupGraphRequest final :
2705     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CleanupGraphRequest) */ {
2706  public:
CleanupGraphRequest()2707   inline CleanupGraphRequest() : CleanupGraphRequest(nullptr) {}
2708   ~CleanupGraphRequest() override;
2709   explicit PROTOBUF_CONSTEXPR CleanupGraphRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2710 
2711   CleanupGraphRequest(const CleanupGraphRequest& from);
CleanupGraphRequest(CleanupGraphRequest && from)2712   CleanupGraphRequest(CleanupGraphRequest&& from) noexcept
2713     : CleanupGraphRequest() {
2714     *this = ::std::move(from);
2715   }
2716 
2717   inline CleanupGraphRequest& operator=(const CleanupGraphRequest& from) {
2718     if (this == &from) return *this;
2719     CopyFrom(from);
2720     return *this;
2721   }
2722   inline CleanupGraphRequest& operator=(CleanupGraphRequest&& from) noexcept {
2723     if (this == &from) return *this;
2724     if (GetOwningArena() == from.GetOwningArena()
2725   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2726         && GetOwningArena() != nullptr
2727   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2728     ) {
2729       InternalSwap(&from);
2730     } else {
2731       CopyFrom(from);
2732     }
2733     return *this;
2734   }
2735 
default_instance()2736   static const CleanupGraphRequest& default_instance() {
2737     return *internal_default_instance();
2738   }
internal_default_instance()2739   static inline const CleanupGraphRequest* internal_default_instance() {
2740     return reinterpret_cast<const CleanupGraphRequest*>(
2741                &_CleanupGraphRequest_default_instance_);
2742   }
2743   static constexpr int kIndexInFileMessages =
2744     15;
2745 
swap(CleanupGraphRequest & a,CleanupGraphRequest & b)2746   friend void swap(CleanupGraphRequest& a, CleanupGraphRequest& b) {
2747     a.Swap(&b);
2748   }
Swap(CleanupGraphRequest * other)2749   inline void Swap(CleanupGraphRequest* other) {
2750     if (other == this) return;
2751   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2752     if (GetOwningArena() != nullptr &&
2753         GetOwningArena() == other->GetOwningArena()) {
2754    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2755     if (GetOwningArena() == other->GetOwningArena()) {
2756   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2757       InternalSwap(other);
2758     } else {
2759       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2760     }
2761   }
2762   void UnsafeArenaSwap(CleanupGraphRequest* other) {
2763     if (other == this) return;
2764     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2765     InternalSwap(other);
2766   }
2767 
2768   // implements Message ----------------------------------------------
2769 
2770   CleanupGraphRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2771     return CreateMaybeMessage<CleanupGraphRequest>(arena);
2772   }
2773   CleanupGraphRequest* New() const {
2774     return New(nullptr);
2775   }
2776   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2777   void CopyFrom(const CleanupGraphRequest& from);
2778   void MergeFrom(const CleanupGraphRequest& from);
2779   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2780   bool IsInitialized() const final;
2781 
2782   size_t ByteSizeLong() const final;
2783   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2784   ::uint8_t* _InternalSerialize(
2785       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2786   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2787 
2788   private:
2789   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2790   void SharedDtor();
2791   void SetCachedSize(int size) const;
2792   void InternalSwap(CleanupGraphRequest* other);
2793 
2794   private:
2795   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2796   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2797     return "tensorflow.CleanupGraphRequest";
2798   }
2799   protected:
2800   explicit CleanupGraphRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2801                        bool is_message_owned = false);
2802   public:
2803 
2804   std::string GetTypeName() const final;
2805 
2806   // nested types ----------------------------------------------------
2807 
2808   // accessors -------------------------------------------------------
2809 
2810   enum : int {
2811     kStepIdFieldNumber = 1,
2812   };
2813   // int64 step_id = 1;
2814   void clear_step_id();
2815   ::int64_t step_id() const;
2816   void set_step_id(::int64_t value);
2817   private:
2818   ::int64_t _internal_step_id() const;
2819   void _internal_set_step_id(::int64_t value);
2820   public:
2821 
2822   // @@protoc_insertion_point(class_scope:tensorflow.CleanupGraphRequest)
2823  private:
2824   class _Internal;
2825 
2826   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2827   typedef void InternalArenaConstructable_;
2828   typedef void DestructorSkippable_;
2829   struct Impl_ {
2830     ::int64_t step_id_;
2831     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2832   };
2833   union { Impl_ _impl_; };
2834   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
2835 };
2836 // -------------------------------------------------------------------
2837 
2838 class CleanupGraphResponse final :
2839     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CleanupGraphResponse) */ {
2840  public:
CleanupGraphResponse()2841   inline CleanupGraphResponse() : CleanupGraphResponse(nullptr) {}
2842   ~CleanupGraphResponse() override;
2843   explicit PROTOBUF_CONSTEXPR CleanupGraphResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2844 
2845   CleanupGraphResponse(const CleanupGraphResponse& from);
CleanupGraphResponse(CleanupGraphResponse && from)2846   CleanupGraphResponse(CleanupGraphResponse&& from) noexcept
2847     : CleanupGraphResponse() {
2848     *this = ::std::move(from);
2849   }
2850 
2851   inline CleanupGraphResponse& operator=(const CleanupGraphResponse& from) {
2852     if (this == &from) return *this;
2853     CopyFrom(from);
2854     return *this;
2855   }
2856   inline CleanupGraphResponse& operator=(CleanupGraphResponse&& from) noexcept {
2857     if (this == &from) return *this;
2858     if (GetOwningArena() == from.GetOwningArena()
2859   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2860         && GetOwningArena() != nullptr
2861   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2862     ) {
2863       InternalSwap(&from);
2864     } else {
2865       CopyFrom(from);
2866     }
2867     return *this;
2868   }
2869 
default_instance()2870   static const CleanupGraphResponse& default_instance() {
2871     return *internal_default_instance();
2872   }
internal_default_instance()2873   static inline const CleanupGraphResponse* internal_default_instance() {
2874     return reinterpret_cast<const CleanupGraphResponse*>(
2875                &_CleanupGraphResponse_default_instance_);
2876   }
2877   static constexpr int kIndexInFileMessages =
2878     16;
2879 
swap(CleanupGraphResponse & a,CleanupGraphResponse & b)2880   friend void swap(CleanupGraphResponse& a, CleanupGraphResponse& b) {
2881     a.Swap(&b);
2882   }
Swap(CleanupGraphResponse * other)2883   inline void Swap(CleanupGraphResponse* other) {
2884     if (other == this) return;
2885   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2886     if (GetOwningArena() != nullptr &&
2887         GetOwningArena() == other->GetOwningArena()) {
2888    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
2889     if (GetOwningArena() == other->GetOwningArena()) {
2890   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
2891       InternalSwap(other);
2892     } else {
2893       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2894     }
2895   }
2896   void UnsafeArenaSwap(CleanupGraphResponse* other) {
2897     if (other == this) return;
2898     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2899     InternalSwap(other);
2900   }
2901 
2902   // implements Message ----------------------------------------------
2903 
2904   CleanupGraphResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2905     return CreateMaybeMessage<CleanupGraphResponse>(arena);
2906   }
2907   CleanupGraphResponse* New() const {
2908     return New(nullptr);
2909   }
2910   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
2911   void CopyFrom(const CleanupGraphResponse& from);
2912   void MergeFrom(const CleanupGraphResponse& from);
2913   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2914   bool IsInitialized() const final;
2915 
2916   size_t ByteSizeLong() const final;
2917   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2918   ::uint8_t* _InternalSerialize(
2919       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2920   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2921 
2922   private:
2923   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2924   void SharedDtor();
2925   void SetCachedSize(int size) const;
2926   void InternalSwap(CleanupGraphResponse* other);
2927 
2928   private:
2929   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2930   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2931     return "tensorflow.CleanupGraphResponse";
2932   }
2933   protected:
2934   explicit CleanupGraphResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2935                        bool is_message_owned = false);
2936   public:
2937 
2938   std::string GetTypeName() const final;
2939 
2940   // nested types ----------------------------------------------------
2941 
2942   // accessors -------------------------------------------------------
2943 
2944   // @@protoc_insertion_point(class_scope:tensorflow.CleanupGraphResponse)
2945  private:
2946   class _Internal;
2947 
2948   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2949   typedef void InternalArenaConstructable_;
2950   typedef void DestructorSkippable_;
2951   struct Impl_ {
2952     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2953   };
2954   union { Impl_ _impl_; };
2955   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
2956 };
2957 // -------------------------------------------------------------------
2958 
2959 class RecvTensorRequest final :
2960     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RecvTensorRequest) */ {
2961  public:
RecvTensorRequest()2962   inline RecvTensorRequest() : RecvTensorRequest(nullptr) {}
2963   ~RecvTensorRequest() override;
2964   explicit PROTOBUF_CONSTEXPR RecvTensorRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2965 
2966   RecvTensorRequest(const RecvTensorRequest& from);
RecvTensorRequest(RecvTensorRequest && from)2967   RecvTensorRequest(RecvTensorRequest&& from) noexcept
2968     : RecvTensorRequest() {
2969     *this = ::std::move(from);
2970   }
2971 
2972   inline RecvTensorRequest& operator=(const RecvTensorRequest& from) {
2973     if (this == &from) return *this;
2974     CopyFrom(from);
2975     return *this;
2976   }
2977   inline RecvTensorRequest& operator=(RecvTensorRequest&& from) noexcept {
2978     if (this == &from) return *this;
2979     if (GetOwningArena() == from.GetOwningArena()
2980   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2981         && GetOwningArena() != nullptr
2982   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
2983     ) {
2984       InternalSwap(&from);
2985     } else {
2986       CopyFrom(from);
2987     }
2988     return *this;
2989   }
2990 
default_instance()2991   static const RecvTensorRequest& default_instance() {
2992     return *internal_default_instance();
2993   }
internal_default_instance()2994   static inline const RecvTensorRequest* internal_default_instance() {
2995     return reinterpret_cast<const RecvTensorRequest*>(
2996                &_RecvTensorRequest_default_instance_);
2997   }
2998   static constexpr int kIndexInFileMessages =
2999     17;
3000 
swap(RecvTensorRequest & a,RecvTensorRequest & b)3001   friend void swap(RecvTensorRequest& a, RecvTensorRequest& b) {
3002     a.Swap(&b);
3003   }
Swap(RecvTensorRequest * other)3004   inline void Swap(RecvTensorRequest* other) {
3005     if (other == this) return;
3006   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3007     if (GetOwningArena() != nullptr &&
3008         GetOwningArena() == other->GetOwningArena()) {
3009    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3010     if (GetOwningArena() == other->GetOwningArena()) {
3011   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3012       InternalSwap(other);
3013     } else {
3014       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3015     }
3016   }
3017   void UnsafeArenaSwap(RecvTensorRequest* other) {
3018     if (other == this) return;
3019     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3020     InternalSwap(other);
3021   }
3022 
3023   // implements Message ----------------------------------------------
3024 
3025   RecvTensorRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3026     return CreateMaybeMessage<RecvTensorRequest>(arena);
3027   }
3028   RecvTensorRequest* New() const {
3029     return New(nullptr);
3030   }
3031   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3032   void CopyFrom(const RecvTensorRequest& from);
3033   void MergeFrom(const RecvTensorRequest& from);
3034   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3035   bool IsInitialized() const final;
3036 
3037   size_t ByteSizeLong() const final;
3038   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3039   ::uint8_t* _InternalSerialize(
3040       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3041   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3042 
3043   private:
3044   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3045   void SharedDtor();
3046   void SetCachedSize(int size) const;
3047   void InternalSwap(RecvTensorRequest* other);
3048 
3049   private:
3050   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3051   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3052     return "tensorflow.RecvTensorRequest";
3053   }
3054   protected:
3055   explicit RecvTensorRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3056                        bool is_message_owned = false);
3057   public:
3058 
3059   std::string GetTypeName() const final;
3060 
3061   // nested types ----------------------------------------------------
3062 
3063   // accessors -------------------------------------------------------
3064 
3065   enum : int {
3066     kRendezvousKeyFieldNumber = 2,
3067     kClientLocalityFieldNumber = 4,
3068     kServerLocalityFieldNumber = 5,
3069     kTransportOptionsFieldNumber = 6,
3070     kStepIdFieldNumber = 1,
3071     kRequestIdFieldNumber = 7,
3072     kDmaOkFieldNumber = 3,
3073   };
3074   // string rendezvous_key = 2;
3075   void clear_rendezvous_key();
3076   const std::string& rendezvous_key() const;
3077   template <typename ArgT0 = const std::string&, typename... ArgT>
3078   void set_rendezvous_key(ArgT0&& arg0, ArgT... args);
3079   std::string* mutable_rendezvous_key();
3080   PROTOBUF_NODISCARD std::string* release_rendezvous_key();
3081   void set_allocated_rendezvous_key(std::string* rendezvous_key);
3082   private:
3083   const std::string& _internal_rendezvous_key() const;
3084   inline PROTOBUF_ALWAYS_INLINE void _internal_set_rendezvous_key(const std::string& value);
3085   std::string* _internal_mutable_rendezvous_key();
3086   public:
3087 
3088   // .tensorflow.DeviceLocality client_locality = 4;
3089   bool has_client_locality() const;
3090   private:
3091   bool _internal_has_client_locality() const;
3092   public:
3093   void clear_client_locality();
3094   const ::tensorflow::DeviceLocality& client_locality() const;
3095   PROTOBUF_NODISCARD ::tensorflow::DeviceLocality* release_client_locality();
3096   ::tensorflow::DeviceLocality* mutable_client_locality();
3097   void set_allocated_client_locality(::tensorflow::DeviceLocality* client_locality);
3098   private:
3099   const ::tensorflow::DeviceLocality& _internal_client_locality() const;
3100   ::tensorflow::DeviceLocality* _internal_mutable_client_locality();
3101   public:
3102   void unsafe_arena_set_allocated_client_locality(
3103       ::tensorflow::DeviceLocality* client_locality);
3104   ::tensorflow::DeviceLocality* unsafe_arena_release_client_locality();
3105 
3106   // .tensorflow.DeviceLocality server_locality = 5;
3107   bool has_server_locality() const;
3108   private:
3109   bool _internal_has_server_locality() const;
3110   public:
3111   void clear_server_locality();
3112   const ::tensorflow::DeviceLocality& server_locality() const;
3113   PROTOBUF_NODISCARD ::tensorflow::DeviceLocality* release_server_locality();
3114   ::tensorflow::DeviceLocality* mutable_server_locality();
3115   void set_allocated_server_locality(::tensorflow::DeviceLocality* server_locality);
3116   private:
3117   const ::tensorflow::DeviceLocality& _internal_server_locality() const;
3118   ::tensorflow::DeviceLocality* _internal_mutable_server_locality();
3119   public:
3120   void unsafe_arena_set_allocated_server_locality(
3121       ::tensorflow::DeviceLocality* server_locality);
3122   ::tensorflow::DeviceLocality* unsafe_arena_release_server_locality();
3123 
3124   // .google.protobuf.Any transport_options = 6;
3125   bool has_transport_options() const;
3126   private:
3127   bool _internal_has_transport_options() const;
3128   public:
3129   void clear_transport_options();
3130   const ::PROTOBUF_NAMESPACE_ID::Any& transport_options() const;
3131   PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_transport_options();
3132   ::PROTOBUF_NAMESPACE_ID::Any* mutable_transport_options();
3133   void set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options);
3134   private:
3135   const ::PROTOBUF_NAMESPACE_ID::Any& _internal_transport_options() const;
3136   ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_transport_options();
3137   public:
3138   void unsafe_arena_set_allocated_transport_options(
3139       ::PROTOBUF_NAMESPACE_ID::Any* transport_options);
3140   ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_transport_options();
3141 
3142   // int64 step_id = 1;
3143   void clear_step_id();
3144   ::int64_t step_id() const;
3145   void set_step_id(::int64_t value);
3146   private:
3147   ::int64_t _internal_step_id() const;
3148   void _internal_set_step_id(::int64_t value);
3149   public:
3150 
3151   // int64 request_id = 7;
3152   void clear_request_id();
3153   ::int64_t request_id() const;
3154   void set_request_id(::int64_t value);
3155   private:
3156   ::int64_t _internal_request_id() const;
3157   void _internal_set_request_id(::int64_t value);
3158   public:
3159 
3160   // bool dma_ok = 3;
3161   void clear_dma_ok();
3162   bool dma_ok() const;
3163   void set_dma_ok(bool value);
3164   private:
3165   bool _internal_dma_ok() const;
3166   void _internal_set_dma_ok(bool value);
3167   public:
3168 
3169   // @@protoc_insertion_point(class_scope:tensorflow.RecvTensorRequest)
3170  private:
3171   class _Internal;
3172 
3173   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3174   typedef void InternalArenaConstructable_;
3175   typedef void DestructorSkippable_;
3176   struct Impl_ {
3177     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rendezvous_key_;
3178     ::tensorflow::DeviceLocality* client_locality_;
3179     ::tensorflow::DeviceLocality* server_locality_;
3180     ::PROTOBUF_NAMESPACE_ID::Any* transport_options_;
3181     ::int64_t step_id_;
3182     ::int64_t request_id_;
3183     bool dma_ok_;
3184     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3185   };
3186   union { Impl_ _impl_; };
3187   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
3188 };
3189 // -------------------------------------------------------------------
3190 
3191 class RecvTensorResponse final :
3192     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RecvTensorResponse) */ {
3193  public:
RecvTensorResponse()3194   inline RecvTensorResponse() : RecvTensorResponse(nullptr) {}
3195   ~RecvTensorResponse() override;
3196   explicit PROTOBUF_CONSTEXPR RecvTensorResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3197 
3198   RecvTensorResponse(const RecvTensorResponse& from);
RecvTensorResponse(RecvTensorResponse && from)3199   RecvTensorResponse(RecvTensorResponse&& from) noexcept
3200     : RecvTensorResponse() {
3201     *this = ::std::move(from);
3202   }
3203 
3204   inline RecvTensorResponse& operator=(const RecvTensorResponse& from) {
3205     if (this == &from) return *this;
3206     CopyFrom(from);
3207     return *this;
3208   }
3209   inline RecvTensorResponse& operator=(RecvTensorResponse&& from) noexcept {
3210     if (this == &from) return *this;
3211     if (GetOwningArena() == from.GetOwningArena()
3212   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3213         && GetOwningArena() != nullptr
3214   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3215     ) {
3216       InternalSwap(&from);
3217     } else {
3218       CopyFrom(from);
3219     }
3220     return *this;
3221   }
3222 
default_instance()3223   static const RecvTensorResponse& default_instance() {
3224     return *internal_default_instance();
3225   }
internal_default_instance()3226   static inline const RecvTensorResponse* internal_default_instance() {
3227     return reinterpret_cast<const RecvTensorResponse*>(
3228                &_RecvTensorResponse_default_instance_);
3229   }
3230   static constexpr int kIndexInFileMessages =
3231     18;
3232 
swap(RecvTensorResponse & a,RecvTensorResponse & b)3233   friend void swap(RecvTensorResponse& a, RecvTensorResponse& b) {
3234     a.Swap(&b);
3235   }
Swap(RecvTensorResponse * other)3236   inline void Swap(RecvTensorResponse* other) {
3237     if (other == this) return;
3238   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3239     if (GetOwningArena() != nullptr &&
3240         GetOwningArena() == other->GetOwningArena()) {
3241    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3242     if (GetOwningArena() == other->GetOwningArena()) {
3243   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3244       InternalSwap(other);
3245     } else {
3246       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3247     }
3248   }
3249   void UnsafeArenaSwap(RecvTensorResponse* other) {
3250     if (other == this) return;
3251     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3252     InternalSwap(other);
3253   }
3254 
3255   // implements Message ----------------------------------------------
3256 
3257   RecvTensorResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3258     return CreateMaybeMessage<RecvTensorResponse>(arena);
3259   }
3260   RecvTensorResponse* New() const {
3261     return New(nullptr);
3262   }
3263   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3264   void CopyFrom(const RecvTensorResponse& from);
3265   void MergeFrom(const RecvTensorResponse& from);
3266   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3267   bool IsInitialized() const final;
3268 
3269   size_t ByteSizeLong() const final;
3270   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3271   ::uint8_t* _InternalSerialize(
3272       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3273   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3274 
3275   private:
3276   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3277   void SharedDtor();
3278   void SetCachedSize(int size) const;
3279   void InternalSwap(RecvTensorResponse* other);
3280 
3281   private:
3282   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3283   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3284     return "tensorflow.RecvTensorResponse";
3285   }
3286   protected:
3287   explicit RecvTensorResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3288                        bool is_message_owned = false);
3289   public:
3290 
3291   std::string GetTypeName() const final;
3292 
3293   // nested types ----------------------------------------------------
3294 
3295   // accessors -------------------------------------------------------
3296 
3297   enum : int {
3298     kTensorFieldNumber = 1,
3299     kTransportOptionsFieldNumber = 4,
3300     kSendStartMicrosFieldNumber = 3,
3301     kIsDeadFieldNumber = 2,
3302     kRequireAckFieldNumber = 5,
3303   };
3304   // .tensorflow.TensorProto tensor = 1;
3305   bool has_tensor() const;
3306   private:
3307   bool _internal_has_tensor() const;
3308   public:
3309   void clear_tensor();
3310   const ::tensorflow::TensorProto& tensor() const;
3311   PROTOBUF_NODISCARD ::tensorflow::TensorProto* release_tensor();
3312   ::tensorflow::TensorProto* mutable_tensor();
3313   void set_allocated_tensor(::tensorflow::TensorProto* tensor);
3314   private:
3315   const ::tensorflow::TensorProto& _internal_tensor() const;
3316   ::tensorflow::TensorProto* _internal_mutable_tensor();
3317   public:
3318   void unsafe_arena_set_allocated_tensor(
3319       ::tensorflow::TensorProto* tensor);
3320   ::tensorflow::TensorProto* unsafe_arena_release_tensor();
3321 
3322   // .google.protobuf.Any transport_options = 4;
3323   bool has_transport_options() const;
3324   private:
3325   bool _internal_has_transport_options() const;
3326   public:
3327   void clear_transport_options();
3328   const ::PROTOBUF_NAMESPACE_ID::Any& transport_options() const;
3329   PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_transport_options();
3330   ::PROTOBUF_NAMESPACE_ID::Any* mutable_transport_options();
3331   void set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options);
3332   private:
3333   const ::PROTOBUF_NAMESPACE_ID::Any& _internal_transport_options() const;
3334   ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_transport_options();
3335   public:
3336   void unsafe_arena_set_allocated_transport_options(
3337       ::PROTOBUF_NAMESPACE_ID::Any* transport_options);
3338   ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_transport_options();
3339 
3340   // int64 send_start_micros = 3;
3341   void clear_send_start_micros();
3342   ::int64_t send_start_micros() const;
3343   void set_send_start_micros(::int64_t value);
3344   private:
3345   ::int64_t _internal_send_start_micros() const;
3346   void _internal_set_send_start_micros(::int64_t value);
3347   public:
3348 
3349   // bool is_dead = 2;
3350   void clear_is_dead();
3351   bool is_dead() const;
3352   void set_is_dead(bool value);
3353   private:
3354   bool _internal_is_dead() const;
3355   void _internal_set_is_dead(bool value);
3356   public:
3357 
3358   // bool require_ack = 5;
3359   void clear_require_ack();
3360   bool require_ack() const;
3361   void set_require_ack(bool value);
3362   private:
3363   bool _internal_require_ack() const;
3364   void _internal_set_require_ack(bool value);
3365   public:
3366 
3367   // @@protoc_insertion_point(class_scope:tensorflow.RecvTensorResponse)
3368  private:
3369   class _Internal;
3370 
3371   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3372   typedef void InternalArenaConstructable_;
3373   typedef void DestructorSkippable_;
3374   struct Impl_ {
3375     ::tensorflow::TensorProto* tensor_;
3376     ::PROTOBUF_NAMESPACE_ID::Any* transport_options_;
3377     ::int64_t send_start_micros_;
3378     bool is_dead_;
3379     bool require_ack_;
3380     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3381   };
3382   union { Impl_ _impl_; };
3383   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
3384 };
3385 // -------------------------------------------------------------------
3386 
3387 class MarkRecvFinishedRequest final :
3388     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MarkRecvFinishedRequest) */ {
3389  public:
MarkRecvFinishedRequest()3390   inline MarkRecvFinishedRequest() : MarkRecvFinishedRequest(nullptr) {}
3391   ~MarkRecvFinishedRequest() override;
3392   explicit PROTOBUF_CONSTEXPR MarkRecvFinishedRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3393 
3394   MarkRecvFinishedRequest(const MarkRecvFinishedRequest& from);
MarkRecvFinishedRequest(MarkRecvFinishedRequest && from)3395   MarkRecvFinishedRequest(MarkRecvFinishedRequest&& from) noexcept
3396     : MarkRecvFinishedRequest() {
3397     *this = ::std::move(from);
3398   }
3399 
3400   inline MarkRecvFinishedRequest& operator=(const MarkRecvFinishedRequest& from) {
3401     if (this == &from) return *this;
3402     CopyFrom(from);
3403     return *this;
3404   }
3405   inline MarkRecvFinishedRequest& operator=(MarkRecvFinishedRequest&& from) noexcept {
3406     if (this == &from) return *this;
3407     if (GetOwningArena() == from.GetOwningArena()
3408   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3409         && GetOwningArena() != nullptr
3410   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3411     ) {
3412       InternalSwap(&from);
3413     } else {
3414       CopyFrom(from);
3415     }
3416     return *this;
3417   }
3418 
default_instance()3419   static const MarkRecvFinishedRequest& default_instance() {
3420     return *internal_default_instance();
3421   }
internal_default_instance()3422   static inline const MarkRecvFinishedRequest* internal_default_instance() {
3423     return reinterpret_cast<const MarkRecvFinishedRequest*>(
3424                &_MarkRecvFinishedRequest_default_instance_);
3425   }
3426   static constexpr int kIndexInFileMessages =
3427     19;
3428 
swap(MarkRecvFinishedRequest & a,MarkRecvFinishedRequest & b)3429   friend void swap(MarkRecvFinishedRequest& a, MarkRecvFinishedRequest& b) {
3430     a.Swap(&b);
3431   }
Swap(MarkRecvFinishedRequest * other)3432   inline void Swap(MarkRecvFinishedRequest* other) {
3433     if (other == this) return;
3434   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3435     if (GetOwningArena() != nullptr &&
3436         GetOwningArena() == other->GetOwningArena()) {
3437    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3438     if (GetOwningArena() == other->GetOwningArena()) {
3439   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3440       InternalSwap(other);
3441     } else {
3442       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3443     }
3444   }
3445   void UnsafeArenaSwap(MarkRecvFinishedRequest* other) {
3446     if (other == this) return;
3447     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3448     InternalSwap(other);
3449   }
3450 
3451   // implements Message ----------------------------------------------
3452 
3453   MarkRecvFinishedRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3454     return CreateMaybeMessage<MarkRecvFinishedRequest>(arena);
3455   }
3456   MarkRecvFinishedRequest* New() const {
3457     return New(nullptr);
3458   }
3459   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3460   void CopyFrom(const MarkRecvFinishedRequest& from);
3461   void MergeFrom(const MarkRecvFinishedRequest& from);
3462   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3463   bool IsInitialized() const final;
3464 
3465   size_t ByteSizeLong() const final;
3466   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3467   ::uint8_t* _InternalSerialize(
3468       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3469   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3470 
3471   private:
3472   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3473   void SharedDtor();
3474   void SetCachedSize(int size) const;
3475   void InternalSwap(MarkRecvFinishedRequest* other);
3476 
3477   private:
3478   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3479   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3480     return "tensorflow.MarkRecvFinishedRequest";
3481   }
3482   protected:
3483   explicit MarkRecvFinishedRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3484                        bool is_message_owned = false);
3485   public:
3486 
3487   std::string GetTypeName() const final;
3488 
3489   // nested types ----------------------------------------------------
3490 
3491   // accessors -------------------------------------------------------
3492 
3493   enum : int {
3494     kRequestIdFieldNumber = 1,
3495   };
3496   // int64 request_id = 1;
3497   void clear_request_id();
3498   ::int64_t request_id() const;
3499   void set_request_id(::int64_t value);
3500   private:
3501   ::int64_t _internal_request_id() const;
3502   void _internal_set_request_id(::int64_t value);
3503   public:
3504 
3505   // @@protoc_insertion_point(class_scope:tensorflow.MarkRecvFinishedRequest)
3506  private:
3507   class _Internal;
3508 
3509   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3510   typedef void InternalArenaConstructable_;
3511   typedef void DestructorSkippable_;
3512   struct Impl_ {
3513     ::int64_t request_id_;
3514     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3515   };
3516   union { Impl_ _impl_; };
3517   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
3518 };
3519 // -------------------------------------------------------------------
3520 
3521 class MarkRecvFinishedResponse final :
3522     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MarkRecvFinishedResponse) */ {
3523  public:
MarkRecvFinishedResponse()3524   inline MarkRecvFinishedResponse() : MarkRecvFinishedResponse(nullptr) {}
3525   ~MarkRecvFinishedResponse() override;
3526   explicit PROTOBUF_CONSTEXPR MarkRecvFinishedResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3527 
3528   MarkRecvFinishedResponse(const MarkRecvFinishedResponse& from);
MarkRecvFinishedResponse(MarkRecvFinishedResponse && from)3529   MarkRecvFinishedResponse(MarkRecvFinishedResponse&& from) noexcept
3530     : MarkRecvFinishedResponse() {
3531     *this = ::std::move(from);
3532   }
3533 
3534   inline MarkRecvFinishedResponse& operator=(const MarkRecvFinishedResponse& from) {
3535     if (this == &from) return *this;
3536     CopyFrom(from);
3537     return *this;
3538   }
3539   inline MarkRecvFinishedResponse& operator=(MarkRecvFinishedResponse&& from) noexcept {
3540     if (this == &from) return *this;
3541     if (GetOwningArena() == from.GetOwningArena()
3542   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3543         && GetOwningArena() != nullptr
3544   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3545     ) {
3546       InternalSwap(&from);
3547     } else {
3548       CopyFrom(from);
3549     }
3550     return *this;
3551   }
3552 
default_instance()3553   static const MarkRecvFinishedResponse& default_instance() {
3554     return *internal_default_instance();
3555   }
internal_default_instance()3556   static inline const MarkRecvFinishedResponse* internal_default_instance() {
3557     return reinterpret_cast<const MarkRecvFinishedResponse*>(
3558                &_MarkRecvFinishedResponse_default_instance_);
3559   }
3560   static constexpr int kIndexInFileMessages =
3561     20;
3562 
swap(MarkRecvFinishedResponse & a,MarkRecvFinishedResponse & b)3563   friend void swap(MarkRecvFinishedResponse& a, MarkRecvFinishedResponse& b) {
3564     a.Swap(&b);
3565   }
Swap(MarkRecvFinishedResponse * other)3566   inline void Swap(MarkRecvFinishedResponse* other) {
3567     if (other == this) return;
3568   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3569     if (GetOwningArena() != nullptr &&
3570         GetOwningArena() == other->GetOwningArena()) {
3571    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3572     if (GetOwningArena() == other->GetOwningArena()) {
3573   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3574       InternalSwap(other);
3575     } else {
3576       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3577     }
3578   }
3579   void UnsafeArenaSwap(MarkRecvFinishedResponse* other) {
3580     if (other == this) return;
3581     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3582     InternalSwap(other);
3583   }
3584 
3585   // implements Message ----------------------------------------------
3586 
3587   MarkRecvFinishedResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3588     return CreateMaybeMessage<MarkRecvFinishedResponse>(arena);
3589   }
3590   MarkRecvFinishedResponse* New() const {
3591     return New(nullptr);
3592   }
3593   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3594   void CopyFrom(const MarkRecvFinishedResponse& from);
3595   void MergeFrom(const MarkRecvFinishedResponse& from);
3596   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3597   bool IsInitialized() const final;
3598 
3599   size_t ByteSizeLong() const final;
3600   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3601   ::uint8_t* _InternalSerialize(
3602       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3603   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3604 
3605   private:
3606   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3607   void SharedDtor();
3608   void SetCachedSize(int size) const;
3609   void InternalSwap(MarkRecvFinishedResponse* other);
3610 
3611   private:
3612   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3613   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3614     return "tensorflow.MarkRecvFinishedResponse";
3615   }
3616   protected:
3617   explicit MarkRecvFinishedResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3618                        bool is_message_owned = false);
3619   public:
3620 
3621   std::string GetTypeName() const final;
3622 
3623   // nested types ----------------------------------------------------
3624 
3625   // accessors -------------------------------------------------------
3626 
3627   // @@protoc_insertion_point(class_scope:tensorflow.MarkRecvFinishedResponse)
3628  private:
3629   class _Internal;
3630 
3631   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3632   typedef void InternalArenaConstructable_;
3633   typedef void DestructorSkippable_;
3634   struct Impl_ {
3635     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3636   };
3637   union { Impl_ _impl_; };
3638   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
3639 };
3640 // -------------------------------------------------------------------
3641 
3642 class LoggingRequest final :
3643     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.LoggingRequest) */ {
3644  public:
LoggingRequest()3645   inline LoggingRequest() : LoggingRequest(nullptr) {}
3646   ~LoggingRequest() override;
3647   explicit PROTOBUF_CONSTEXPR LoggingRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3648 
3649   LoggingRequest(const LoggingRequest& from);
LoggingRequest(LoggingRequest && from)3650   LoggingRequest(LoggingRequest&& from) noexcept
3651     : LoggingRequest() {
3652     *this = ::std::move(from);
3653   }
3654 
3655   inline LoggingRequest& operator=(const LoggingRequest& from) {
3656     if (this == &from) return *this;
3657     CopyFrom(from);
3658     return *this;
3659   }
3660   inline LoggingRequest& operator=(LoggingRequest&& from) noexcept {
3661     if (this == &from) return *this;
3662     if (GetOwningArena() == from.GetOwningArena()
3663   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3664         && GetOwningArena() != nullptr
3665   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3666     ) {
3667       InternalSwap(&from);
3668     } else {
3669       CopyFrom(from);
3670     }
3671     return *this;
3672   }
3673 
default_instance()3674   static const LoggingRequest& default_instance() {
3675     return *internal_default_instance();
3676   }
internal_default_instance()3677   static inline const LoggingRequest* internal_default_instance() {
3678     return reinterpret_cast<const LoggingRequest*>(
3679                &_LoggingRequest_default_instance_);
3680   }
3681   static constexpr int kIndexInFileMessages =
3682     21;
3683 
swap(LoggingRequest & a,LoggingRequest & b)3684   friend void swap(LoggingRequest& a, LoggingRequest& b) {
3685     a.Swap(&b);
3686   }
Swap(LoggingRequest * other)3687   inline void Swap(LoggingRequest* other) {
3688     if (other == this) return;
3689   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3690     if (GetOwningArena() != nullptr &&
3691         GetOwningArena() == other->GetOwningArena()) {
3692    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3693     if (GetOwningArena() == other->GetOwningArena()) {
3694   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3695       InternalSwap(other);
3696     } else {
3697       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3698     }
3699   }
3700   void UnsafeArenaSwap(LoggingRequest* other) {
3701     if (other == this) return;
3702     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3703     InternalSwap(other);
3704   }
3705 
3706   // implements Message ----------------------------------------------
3707 
3708   LoggingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3709     return CreateMaybeMessage<LoggingRequest>(arena);
3710   }
3711   LoggingRequest* New() const {
3712     return New(nullptr);
3713   }
3714   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3715   void CopyFrom(const LoggingRequest& from);
3716   void MergeFrom(const LoggingRequest& from);
3717   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3718   bool IsInitialized() const final;
3719 
3720   size_t ByteSizeLong() const final;
3721   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3722   ::uint8_t* _InternalSerialize(
3723       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3724   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3725 
3726   private:
3727   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3728   void SharedDtor();
3729   void SetCachedSize(int size) const;
3730   void InternalSwap(LoggingRequest* other);
3731 
3732   private:
3733   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3734   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3735     return "tensorflow.LoggingRequest";
3736   }
3737   protected:
3738   explicit LoggingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3739                        bool is_message_owned = false);
3740   public:
3741 
3742   std::string GetTypeName() const final;
3743 
3744   // nested types ----------------------------------------------------
3745 
3746   // accessors -------------------------------------------------------
3747 
3748   enum : int {
3749     kFetchStepIdFieldNumber = 3,
3750     kEnableRpcLoggingFieldNumber = 1,
3751     kDisableRpcLoggingFieldNumber = 4,
3752     kClearFieldNumber = 2,
3753   };
3754   // repeated int64 fetch_step_id = 3;
3755   int fetch_step_id_size() const;
3756   private:
3757   int _internal_fetch_step_id_size() const;
3758   public:
3759   void clear_fetch_step_id();
3760   private:
3761   ::int64_t _internal_fetch_step_id(int index) const;
3762   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
3763       _internal_fetch_step_id() const;
3764   void _internal_add_fetch_step_id(::int64_t value);
3765   ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
3766       _internal_mutable_fetch_step_id();
3767   public:
3768   ::int64_t fetch_step_id(int index) const;
3769   void set_fetch_step_id(int index, ::int64_t value);
3770   void add_fetch_step_id(::int64_t value);
3771   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
3772       fetch_step_id() const;
3773   ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
3774       mutable_fetch_step_id();
3775 
3776   // bool enable_rpc_logging = 1;
3777   void clear_enable_rpc_logging();
3778   bool enable_rpc_logging() const;
3779   void set_enable_rpc_logging(bool value);
3780   private:
3781   bool _internal_enable_rpc_logging() const;
3782   void _internal_set_enable_rpc_logging(bool value);
3783   public:
3784 
3785   // bool disable_rpc_logging = 4;
3786   void clear_disable_rpc_logging();
3787   bool disable_rpc_logging() const;
3788   void set_disable_rpc_logging(bool value);
3789   private:
3790   bool _internal_disable_rpc_logging() const;
3791   void _internal_set_disable_rpc_logging(bool value);
3792   public:
3793 
3794   // bool clear = 2;
3795   void clear_clear();
3796   bool clear() const;
3797   void set_clear(bool value);
3798   private:
3799   bool _internal_clear() const;
3800   void _internal_set_clear(bool value);
3801   public:
3802 
3803   // @@protoc_insertion_point(class_scope:tensorflow.LoggingRequest)
3804  private:
3805   class _Internal;
3806 
3807   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3808   typedef void InternalArenaConstructable_;
3809   typedef void DestructorSkippable_;
3810   struct Impl_ {
3811     ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > fetch_step_id_;
3812     mutable std::atomic<int> _fetch_step_id_cached_byte_size_;
3813     bool enable_rpc_logging_;
3814     bool disable_rpc_logging_;
3815     bool clear_;
3816     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3817   };
3818   union { Impl_ _impl_; };
3819   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
3820 };
3821 // -------------------------------------------------------------------
3822 
3823 class LabeledStepStats final :
3824     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.LabeledStepStats) */ {
3825  public:
LabeledStepStats()3826   inline LabeledStepStats() : LabeledStepStats(nullptr) {}
3827   ~LabeledStepStats() override;
3828   explicit PROTOBUF_CONSTEXPR LabeledStepStats(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3829 
3830   LabeledStepStats(const LabeledStepStats& from);
LabeledStepStats(LabeledStepStats && from)3831   LabeledStepStats(LabeledStepStats&& from) noexcept
3832     : LabeledStepStats() {
3833     *this = ::std::move(from);
3834   }
3835 
3836   inline LabeledStepStats& operator=(const LabeledStepStats& from) {
3837     if (this == &from) return *this;
3838     CopyFrom(from);
3839     return *this;
3840   }
3841   inline LabeledStepStats& operator=(LabeledStepStats&& from) noexcept {
3842     if (this == &from) return *this;
3843     if (GetOwningArena() == from.GetOwningArena()
3844   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3845         && GetOwningArena() != nullptr
3846   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
3847     ) {
3848       InternalSwap(&from);
3849     } else {
3850       CopyFrom(from);
3851     }
3852     return *this;
3853   }
3854 
default_instance()3855   static const LabeledStepStats& default_instance() {
3856     return *internal_default_instance();
3857   }
internal_default_instance()3858   static inline const LabeledStepStats* internal_default_instance() {
3859     return reinterpret_cast<const LabeledStepStats*>(
3860                &_LabeledStepStats_default_instance_);
3861   }
3862   static constexpr int kIndexInFileMessages =
3863     22;
3864 
swap(LabeledStepStats & a,LabeledStepStats & b)3865   friend void swap(LabeledStepStats& a, LabeledStepStats& b) {
3866     a.Swap(&b);
3867   }
Swap(LabeledStepStats * other)3868   inline void Swap(LabeledStepStats* other) {
3869     if (other == this) return;
3870   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3871     if (GetOwningArena() != nullptr &&
3872         GetOwningArena() == other->GetOwningArena()) {
3873    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
3874     if (GetOwningArena() == other->GetOwningArena()) {
3875   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
3876       InternalSwap(other);
3877     } else {
3878       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3879     }
3880   }
3881   void UnsafeArenaSwap(LabeledStepStats* other) {
3882     if (other == this) return;
3883     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3884     InternalSwap(other);
3885   }
3886 
3887   // implements Message ----------------------------------------------
3888 
3889   LabeledStepStats* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3890     return CreateMaybeMessage<LabeledStepStats>(arena);
3891   }
3892   LabeledStepStats* New() const {
3893     return New(nullptr);
3894   }
3895   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
3896   void CopyFrom(const LabeledStepStats& from);
3897   void MergeFrom(const LabeledStepStats& from);
3898   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3899   bool IsInitialized() const final;
3900 
3901   size_t ByteSizeLong() const final;
3902   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3903   ::uint8_t* _InternalSerialize(
3904       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3905   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3906 
3907   private:
3908   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3909   void SharedDtor();
3910   void SetCachedSize(int size) const;
3911   void InternalSwap(LabeledStepStats* other);
3912 
3913   private:
3914   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3915   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3916     return "tensorflow.LabeledStepStats";
3917   }
3918   protected:
3919   explicit LabeledStepStats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3920                        bool is_message_owned = false);
3921   public:
3922 
3923   std::string GetTypeName() const final;
3924 
3925   // nested types ----------------------------------------------------
3926 
3927   // accessors -------------------------------------------------------
3928 
3929   enum : int {
3930     kStepStatsFieldNumber = 2,
3931     kStepIdFieldNumber = 1,
3932   };
3933   // .tensorflow.StepStats step_stats = 2;
3934   bool has_step_stats() const;
3935   private:
3936   bool _internal_has_step_stats() const;
3937   public:
3938   void clear_step_stats();
3939   const ::tensorflow::StepStats& step_stats() const;
3940   PROTOBUF_NODISCARD ::tensorflow::StepStats* release_step_stats();
3941   ::tensorflow::StepStats* mutable_step_stats();
3942   void set_allocated_step_stats(::tensorflow::StepStats* step_stats);
3943   private:
3944   const ::tensorflow::StepStats& _internal_step_stats() const;
3945   ::tensorflow::StepStats* _internal_mutable_step_stats();
3946   public:
3947   void unsafe_arena_set_allocated_step_stats(
3948       ::tensorflow::StepStats* step_stats);
3949   ::tensorflow::StepStats* unsafe_arena_release_step_stats();
3950 
3951   // int64 step_id = 1;
3952   void clear_step_id();
3953   ::int64_t step_id() const;
3954   void set_step_id(::int64_t value);
3955   private:
3956   ::int64_t _internal_step_id() const;
3957   void _internal_set_step_id(::int64_t value);
3958   public:
3959 
3960   // @@protoc_insertion_point(class_scope:tensorflow.LabeledStepStats)
3961  private:
3962   class _Internal;
3963 
3964   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3965   typedef void InternalArenaConstructable_;
3966   typedef void DestructorSkippable_;
3967   struct Impl_ {
3968     ::tensorflow::StepStats* step_stats_;
3969     ::int64_t step_id_;
3970     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3971   };
3972   union { Impl_ _impl_; };
3973   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
3974 };
3975 // -------------------------------------------------------------------
3976 
3977 class LoggingResponse final :
3978     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.LoggingResponse) */ {
3979  public:
LoggingResponse()3980   inline LoggingResponse() : LoggingResponse(nullptr) {}
3981   ~LoggingResponse() override;
3982   explicit PROTOBUF_CONSTEXPR LoggingResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3983 
3984   LoggingResponse(const LoggingResponse& from);
LoggingResponse(LoggingResponse && from)3985   LoggingResponse(LoggingResponse&& from) noexcept
3986     : LoggingResponse() {
3987     *this = ::std::move(from);
3988   }
3989 
3990   inline LoggingResponse& operator=(const LoggingResponse& from) {
3991     if (this == &from) return *this;
3992     CopyFrom(from);
3993     return *this;
3994   }
3995   inline LoggingResponse& operator=(LoggingResponse&& from) noexcept {
3996     if (this == &from) return *this;
3997     if (GetOwningArena() == from.GetOwningArena()
3998   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3999         && GetOwningArena() != nullptr
4000   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4001     ) {
4002       InternalSwap(&from);
4003     } else {
4004       CopyFrom(from);
4005     }
4006     return *this;
4007   }
4008 
default_instance()4009   static const LoggingResponse& default_instance() {
4010     return *internal_default_instance();
4011   }
internal_default_instance()4012   static inline const LoggingResponse* internal_default_instance() {
4013     return reinterpret_cast<const LoggingResponse*>(
4014                &_LoggingResponse_default_instance_);
4015   }
4016   static constexpr int kIndexInFileMessages =
4017     23;
4018 
swap(LoggingResponse & a,LoggingResponse & b)4019   friend void swap(LoggingResponse& a, LoggingResponse& b) {
4020     a.Swap(&b);
4021   }
Swap(LoggingResponse * other)4022   inline void Swap(LoggingResponse* other) {
4023     if (other == this) return;
4024   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4025     if (GetOwningArena() != nullptr &&
4026         GetOwningArena() == other->GetOwningArena()) {
4027    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4028     if (GetOwningArena() == other->GetOwningArena()) {
4029   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4030       InternalSwap(other);
4031     } else {
4032       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4033     }
4034   }
4035   void UnsafeArenaSwap(LoggingResponse* other) {
4036     if (other == this) return;
4037     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4038     InternalSwap(other);
4039   }
4040 
4041   // implements Message ----------------------------------------------
4042 
4043   LoggingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4044     return CreateMaybeMessage<LoggingResponse>(arena);
4045   }
4046   LoggingResponse* New() const {
4047     return New(nullptr);
4048   }
4049   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
4050   void CopyFrom(const LoggingResponse& from);
4051   void MergeFrom(const LoggingResponse& from);
4052   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4053   bool IsInitialized() const final;
4054 
4055   size_t ByteSizeLong() const final;
4056   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4057   ::uint8_t* _InternalSerialize(
4058       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4059   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4060 
4061   private:
4062   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4063   void SharedDtor();
4064   void SetCachedSize(int size) const;
4065   void InternalSwap(LoggingResponse* other);
4066 
4067   private:
4068   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4069   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4070     return "tensorflow.LoggingResponse";
4071   }
4072   protected:
4073   explicit LoggingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4074                        bool is_message_owned = false);
4075   public:
4076 
4077   std::string GetTypeName() const final;
4078 
4079   // nested types ----------------------------------------------------
4080 
4081   // accessors -------------------------------------------------------
4082 
4083   enum : int {
4084     kStepFieldNumber = 1,
4085   };
4086   // repeated .tensorflow.LabeledStepStats step = 1;
4087   int step_size() const;
4088   private:
4089   int _internal_step_size() const;
4090   public:
4091   void clear_step();
4092   ::tensorflow::LabeledStepStats* mutable_step(int index);
4093   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::LabeledStepStats >*
4094       mutable_step();
4095   private:
4096   const ::tensorflow::LabeledStepStats& _internal_step(int index) const;
4097   ::tensorflow::LabeledStepStats* _internal_add_step();
4098   public:
4099   const ::tensorflow::LabeledStepStats& step(int index) const;
4100   ::tensorflow::LabeledStepStats* add_step();
4101   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::LabeledStepStats >&
4102       step() const;
4103 
4104   // @@protoc_insertion_point(class_scope:tensorflow.LoggingResponse)
4105  private:
4106   class _Internal;
4107 
4108   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4109   typedef void InternalArenaConstructable_;
4110   typedef void DestructorSkippable_;
4111   struct Impl_ {
4112     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::LabeledStepStats > step_;
4113     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4114   };
4115   union { Impl_ _impl_; };
4116   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
4117 };
4118 // -------------------------------------------------------------------
4119 
4120 class TraceOpts final :
4121     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TraceOpts) */ {
4122  public:
TraceOpts()4123   inline TraceOpts() : TraceOpts(nullptr) {}
4124   ~TraceOpts() override;
4125   explicit PROTOBUF_CONSTEXPR TraceOpts(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4126 
4127   TraceOpts(const TraceOpts& from);
TraceOpts(TraceOpts && from)4128   TraceOpts(TraceOpts&& from) noexcept
4129     : TraceOpts() {
4130     *this = ::std::move(from);
4131   }
4132 
4133   inline TraceOpts& operator=(const TraceOpts& from) {
4134     if (this == &from) return *this;
4135     CopyFrom(from);
4136     return *this;
4137   }
4138   inline TraceOpts& operator=(TraceOpts&& from) noexcept {
4139     if (this == &from) return *this;
4140     if (GetOwningArena() == from.GetOwningArena()
4141   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4142         && GetOwningArena() != nullptr
4143   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4144     ) {
4145       InternalSwap(&from);
4146     } else {
4147       CopyFrom(from);
4148     }
4149     return *this;
4150   }
4151 
default_instance()4152   static const TraceOpts& default_instance() {
4153     return *internal_default_instance();
4154   }
internal_default_instance()4155   static inline const TraceOpts* internal_default_instance() {
4156     return reinterpret_cast<const TraceOpts*>(
4157                &_TraceOpts_default_instance_);
4158   }
4159   static constexpr int kIndexInFileMessages =
4160     24;
4161 
swap(TraceOpts & a,TraceOpts & b)4162   friend void swap(TraceOpts& a, TraceOpts& b) {
4163     a.Swap(&b);
4164   }
Swap(TraceOpts * other)4165   inline void Swap(TraceOpts* other) {
4166     if (other == this) return;
4167   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4168     if (GetOwningArena() != nullptr &&
4169         GetOwningArena() == other->GetOwningArena()) {
4170    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4171     if (GetOwningArena() == other->GetOwningArena()) {
4172   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4173       InternalSwap(other);
4174     } else {
4175       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4176     }
4177   }
4178   void UnsafeArenaSwap(TraceOpts* other) {
4179     if (other == this) return;
4180     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4181     InternalSwap(other);
4182   }
4183 
4184   // implements Message ----------------------------------------------
4185 
4186   TraceOpts* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4187     return CreateMaybeMessage<TraceOpts>(arena);
4188   }
4189   TraceOpts* New() const {
4190     return New(nullptr);
4191   }
4192   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
4193   void CopyFrom(const TraceOpts& from);
4194   void MergeFrom(const TraceOpts& from);
4195   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4196   bool IsInitialized() const final;
4197 
4198   size_t ByteSizeLong() const final;
4199   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4200   ::uint8_t* _InternalSerialize(
4201       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4202   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4203 
4204   private:
4205   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4206   void SharedDtor();
4207   void SetCachedSize(int size) const;
4208   void InternalSwap(TraceOpts* other);
4209 
4210   private:
4211   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4212   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4213     return "tensorflow.TraceOpts";
4214   }
4215   protected:
4216   explicit TraceOpts(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4217                        bool is_message_owned = false);
4218   public:
4219 
4220   std::string GetTypeName() const final;
4221 
4222   // nested types ----------------------------------------------------
4223 
4224   // accessors -------------------------------------------------------
4225 
4226   enum : int {
4227     kDurationFieldNumber = 1,
4228     kUseStepProfilerFieldNumber = 2,
4229     kUseKernelProfilerFieldNumber = 3,
4230     kUseExtendedProfilerFieldNumber = 4,
4231     kUseGpuProfilerFieldNumber = 5,
4232     kUseSampleProfilerFieldNumber = 6,
4233   };
4234   // double duration = 1;
4235   void clear_duration();
4236   double duration() const;
4237   void set_duration(double value);
4238   private:
4239   double _internal_duration() const;
4240   void _internal_set_duration(double value);
4241   public:
4242 
4243   // bool use_step_profiler = 2;
4244   void clear_use_step_profiler();
4245   bool use_step_profiler() const;
4246   void set_use_step_profiler(bool value);
4247   private:
4248   bool _internal_use_step_profiler() const;
4249   void _internal_set_use_step_profiler(bool value);
4250   public:
4251 
4252   // bool use_kernel_profiler = 3;
4253   void clear_use_kernel_profiler();
4254   bool use_kernel_profiler() const;
4255   void set_use_kernel_profiler(bool value);
4256   private:
4257   bool _internal_use_kernel_profiler() const;
4258   void _internal_set_use_kernel_profiler(bool value);
4259   public:
4260 
4261   // bool use_extended_profiler = 4;
4262   void clear_use_extended_profiler();
4263   bool use_extended_profiler() const;
4264   void set_use_extended_profiler(bool value);
4265   private:
4266   bool _internal_use_extended_profiler() const;
4267   void _internal_set_use_extended_profiler(bool value);
4268   public:
4269 
4270   // bool use_gpu_profiler = 5;
4271   void clear_use_gpu_profiler();
4272   bool use_gpu_profiler() const;
4273   void set_use_gpu_profiler(bool value);
4274   private:
4275   bool _internal_use_gpu_profiler() const;
4276   void _internal_set_use_gpu_profiler(bool value);
4277   public:
4278 
4279   // bool use_sample_profiler = 6;
4280   void clear_use_sample_profiler();
4281   bool use_sample_profiler() const;
4282   void set_use_sample_profiler(bool value);
4283   private:
4284   bool _internal_use_sample_profiler() const;
4285   void _internal_set_use_sample_profiler(bool value);
4286   public:
4287 
4288   // @@protoc_insertion_point(class_scope:tensorflow.TraceOpts)
4289  private:
4290   class _Internal;
4291 
4292   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4293   typedef void InternalArenaConstructable_;
4294   typedef void DestructorSkippable_;
4295   struct Impl_ {
4296     double duration_;
4297     bool use_step_profiler_;
4298     bool use_kernel_profiler_;
4299     bool use_extended_profiler_;
4300     bool use_gpu_profiler_;
4301     bool use_sample_profiler_;
4302     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4303   };
4304   union { Impl_ _impl_; };
4305   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
4306 };
4307 // -------------------------------------------------------------------
4308 
4309 class TracingRequest final :
4310     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TracingRequest) */ {
4311  public:
TracingRequest()4312   inline TracingRequest() : TracingRequest(nullptr) {}
4313   ~TracingRequest() override;
4314   explicit PROTOBUF_CONSTEXPR TracingRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4315 
4316   TracingRequest(const TracingRequest& from);
TracingRequest(TracingRequest && from)4317   TracingRequest(TracingRequest&& from) noexcept
4318     : TracingRequest() {
4319     *this = ::std::move(from);
4320   }
4321 
4322   inline TracingRequest& operator=(const TracingRequest& from) {
4323     if (this == &from) return *this;
4324     CopyFrom(from);
4325     return *this;
4326   }
4327   inline TracingRequest& operator=(TracingRequest&& from) noexcept {
4328     if (this == &from) return *this;
4329     if (GetOwningArena() == from.GetOwningArena()
4330   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4331         && GetOwningArena() != nullptr
4332   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4333     ) {
4334       InternalSwap(&from);
4335     } else {
4336       CopyFrom(from);
4337     }
4338     return *this;
4339   }
4340 
default_instance()4341   static const TracingRequest& default_instance() {
4342     return *internal_default_instance();
4343   }
internal_default_instance()4344   static inline const TracingRequest* internal_default_instance() {
4345     return reinterpret_cast<const TracingRequest*>(
4346                &_TracingRequest_default_instance_);
4347   }
4348   static constexpr int kIndexInFileMessages =
4349     25;
4350 
swap(TracingRequest & a,TracingRequest & b)4351   friend void swap(TracingRequest& a, TracingRequest& b) {
4352     a.Swap(&b);
4353   }
Swap(TracingRequest * other)4354   inline void Swap(TracingRequest* other) {
4355     if (other == this) return;
4356   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4357     if (GetOwningArena() != nullptr &&
4358         GetOwningArena() == other->GetOwningArena()) {
4359    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4360     if (GetOwningArena() == other->GetOwningArena()) {
4361   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4362       InternalSwap(other);
4363     } else {
4364       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4365     }
4366   }
4367   void UnsafeArenaSwap(TracingRequest* other) {
4368     if (other == this) return;
4369     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4370     InternalSwap(other);
4371   }
4372 
4373   // implements Message ----------------------------------------------
4374 
4375   TracingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4376     return CreateMaybeMessage<TracingRequest>(arena);
4377   }
4378   TracingRequest* New() const {
4379     return New(nullptr);
4380   }
4381   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
4382   void CopyFrom(const TracingRequest& from);
4383   void MergeFrom(const TracingRequest& from);
4384   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4385   bool IsInitialized() const final;
4386 
4387   size_t ByteSizeLong() const final;
4388   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4389   ::uint8_t* _InternalSerialize(
4390       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4391   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4392 
4393   private:
4394   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4395   void SharedDtor();
4396   void SetCachedSize(int size) const;
4397   void InternalSwap(TracingRequest* other);
4398 
4399   private:
4400   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4401   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4402     return "tensorflow.TracingRequest";
4403   }
4404   protected:
4405   explicit TracingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4406                        bool is_message_owned = false);
4407   public:
4408 
4409   std::string GetTypeName() const final;
4410 
4411   // nested types ----------------------------------------------------
4412 
4413   // accessors -------------------------------------------------------
4414 
4415   enum : int {
4416     kOptionsFieldNumber = 1,
4417   };
4418   // .tensorflow.TraceOpts options = 1;
4419   bool has_options() const;
4420   private:
4421   bool _internal_has_options() const;
4422   public:
4423   void clear_options();
4424   const ::tensorflow::TraceOpts& options() const;
4425   PROTOBUF_NODISCARD ::tensorflow::TraceOpts* release_options();
4426   ::tensorflow::TraceOpts* mutable_options();
4427   void set_allocated_options(::tensorflow::TraceOpts* options);
4428   private:
4429   const ::tensorflow::TraceOpts& _internal_options() const;
4430   ::tensorflow::TraceOpts* _internal_mutable_options();
4431   public:
4432   void unsafe_arena_set_allocated_options(
4433       ::tensorflow::TraceOpts* options);
4434   ::tensorflow::TraceOpts* unsafe_arena_release_options();
4435 
4436   // @@protoc_insertion_point(class_scope:tensorflow.TracingRequest)
4437  private:
4438   class _Internal;
4439 
4440   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4441   typedef void InternalArenaConstructable_;
4442   typedef void DestructorSkippable_;
4443   struct Impl_ {
4444     ::tensorflow::TraceOpts* options_;
4445     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4446   };
4447   union { Impl_ _impl_; };
4448   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
4449 };
4450 // -------------------------------------------------------------------
4451 
4452 class TracingResponse final :
4453     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.TracingResponse) */ {
4454  public:
TracingResponse()4455   inline TracingResponse() : TracingResponse(nullptr) {}
4456   ~TracingResponse() override;
4457   explicit PROTOBUF_CONSTEXPR TracingResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4458 
4459   TracingResponse(const TracingResponse& from);
TracingResponse(TracingResponse && from)4460   TracingResponse(TracingResponse&& from) noexcept
4461     : TracingResponse() {
4462     *this = ::std::move(from);
4463   }
4464 
4465   inline TracingResponse& operator=(const TracingResponse& from) {
4466     if (this == &from) return *this;
4467     CopyFrom(from);
4468     return *this;
4469   }
4470   inline TracingResponse& operator=(TracingResponse&& from) noexcept {
4471     if (this == &from) return *this;
4472     if (GetOwningArena() == from.GetOwningArena()
4473   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4474         && GetOwningArena() != nullptr
4475   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4476     ) {
4477       InternalSwap(&from);
4478     } else {
4479       CopyFrom(from);
4480     }
4481     return *this;
4482   }
4483 
default_instance()4484   static const TracingResponse& default_instance() {
4485     return *internal_default_instance();
4486   }
internal_default_instance()4487   static inline const TracingResponse* internal_default_instance() {
4488     return reinterpret_cast<const TracingResponse*>(
4489                &_TracingResponse_default_instance_);
4490   }
4491   static constexpr int kIndexInFileMessages =
4492     26;
4493 
swap(TracingResponse & a,TracingResponse & b)4494   friend void swap(TracingResponse& a, TracingResponse& b) {
4495     a.Swap(&b);
4496   }
Swap(TracingResponse * other)4497   inline void Swap(TracingResponse* other) {
4498     if (other == this) return;
4499   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4500     if (GetOwningArena() != nullptr &&
4501         GetOwningArena() == other->GetOwningArena()) {
4502    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4503     if (GetOwningArena() == other->GetOwningArena()) {
4504   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4505       InternalSwap(other);
4506     } else {
4507       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4508     }
4509   }
4510   void UnsafeArenaSwap(TracingResponse* other) {
4511     if (other == this) return;
4512     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4513     InternalSwap(other);
4514   }
4515 
4516   // implements Message ----------------------------------------------
4517 
4518   TracingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4519     return CreateMaybeMessage<TracingResponse>(arena);
4520   }
4521   TracingResponse* New() const {
4522     return New(nullptr);
4523   }
4524   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
4525   void CopyFrom(const TracingResponse& from);
4526   void MergeFrom(const TracingResponse& from);
4527   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4528   bool IsInitialized() const final;
4529 
4530   size_t ByteSizeLong() const final;
4531   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4532   ::uint8_t* _InternalSerialize(
4533       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4534   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4535 
4536   private:
4537   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4538   void SharedDtor();
4539   void SetCachedSize(int size) const;
4540   void InternalSwap(TracingResponse* other);
4541 
4542   private:
4543   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4544   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4545     return "tensorflow.TracingResponse";
4546   }
4547   protected:
4548   explicit TracingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4549                        bool is_message_owned = false);
4550   public:
4551 
4552   std::string GetTypeName() const final;
4553 
4554   // nested types ----------------------------------------------------
4555 
4556   // accessors -------------------------------------------------------
4557 
4558   // @@protoc_insertion_point(class_scope:tensorflow.TracingResponse)
4559  private:
4560   class _Internal;
4561 
4562   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4563   typedef void InternalArenaConstructable_;
4564   typedef void DestructorSkippable_;
4565   struct Impl_ {
4566     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4567   };
4568   union { Impl_ _impl_; };
4569   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
4570 };
4571 // -------------------------------------------------------------------
4572 
4573 class RecvBufRequest final :
4574     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RecvBufRequest) */ {
4575  public:
RecvBufRequest()4576   inline RecvBufRequest() : RecvBufRequest(nullptr) {}
4577   ~RecvBufRequest() override;
4578   explicit PROTOBUF_CONSTEXPR RecvBufRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4579 
4580   RecvBufRequest(const RecvBufRequest& from);
RecvBufRequest(RecvBufRequest && from)4581   RecvBufRequest(RecvBufRequest&& from) noexcept
4582     : RecvBufRequest() {
4583     *this = ::std::move(from);
4584   }
4585 
4586   inline RecvBufRequest& operator=(const RecvBufRequest& from) {
4587     if (this == &from) return *this;
4588     CopyFrom(from);
4589     return *this;
4590   }
4591   inline RecvBufRequest& operator=(RecvBufRequest&& from) noexcept {
4592     if (this == &from) return *this;
4593     if (GetOwningArena() == from.GetOwningArena()
4594   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4595         && GetOwningArena() != nullptr
4596   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4597     ) {
4598       InternalSwap(&from);
4599     } else {
4600       CopyFrom(from);
4601     }
4602     return *this;
4603   }
4604 
default_instance()4605   static const RecvBufRequest& default_instance() {
4606     return *internal_default_instance();
4607   }
internal_default_instance()4608   static inline const RecvBufRequest* internal_default_instance() {
4609     return reinterpret_cast<const RecvBufRequest*>(
4610                &_RecvBufRequest_default_instance_);
4611   }
4612   static constexpr int kIndexInFileMessages =
4613     27;
4614 
swap(RecvBufRequest & a,RecvBufRequest & b)4615   friend void swap(RecvBufRequest& a, RecvBufRequest& b) {
4616     a.Swap(&b);
4617   }
Swap(RecvBufRequest * other)4618   inline void Swap(RecvBufRequest* other) {
4619     if (other == this) return;
4620   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4621     if (GetOwningArena() != nullptr &&
4622         GetOwningArena() == other->GetOwningArena()) {
4623    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4624     if (GetOwningArena() == other->GetOwningArena()) {
4625   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4626       InternalSwap(other);
4627     } else {
4628       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4629     }
4630   }
4631   void UnsafeArenaSwap(RecvBufRequest* other) {
4632     if (other == this) return;
4633     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4634     InternalSwap(other);
4635   }
4636 
4637   // implements Message ----------------------------------------------
4638 
4639   RecvBufRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4640     return CreateMaybeMessage<RecvBufRequest>(arena);
4641   }
4642   RecvBufRequest* New() const {
4643     return New(nullptr);
4644   }
4645   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
4646   void CopyFrom(const RecvBufRequest& from);
4647   void MergeFrom(const RecvBufRequest& from);
4648   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4649   bool IsInitialized() const final;
4650 
4651   size_t ByteSizeLong() const final;
4652   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4653   ::uint8_t* _InternalSerialize(
4654       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4655   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4656 
4657   private:
4658   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4659   void SharedDtor();
4660   void SetCachedSize(int size) const;
4661   void InternalSwap(RecvBufRequest* other);
4662 
4663   private:
4664   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4665   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4666     return "tensorflow.RecvBufRequest";
4667   }
4668   protected:
4669   explicit RecvBufRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4670                        bool is_message_owned = false);
4671   public:
4672 
4673   std::string GetTypeName() const final;
4674 
4675   // nested types ----------------------------------------------------
4676 
4677   // accessors -------------------------------------------------------
4678 
4679   enum : int {
4680     kBufRendezvousKeyFieldNumber = 2,
4681     kSrcDeviceFieldNumber = 8,
4682     kDstDeviceFieldNumber = 9,
4683     kClientLocalityFieldNumber = 5,
4684     kServerLocalityFieldNumber = 6,
4685     kTransportOptionsFieldNumber = 7,
4686     kStepIdFieldNumber = 1,
4687     kNumBytesFieldNumber = 3,
4688     kBufPtrFieldNumber = 4,
4689     kRequestIdFieldNumber = 10,
4690     kSrcIncarnationFieldNumber = 11,
4691   };
4692   // string buf_rendezvous_key = 2;
4693   void clear_buf_rendezvous_key();
4694   const std::string& buf_rendezvous_key() const;
4695   template <typename ArgT0 = const std::string&, typename... ArgT>
4696   void set_buf_rendezvous_key(ArgT0&& arg0, ArgT... args);
4697   std::string* mutable_buf_rendezvous_key();
4698   PROTOBUF_NODISCARD std::string* release_buf_rendezvous_key();
4699   void set_allocated_buf_rendezvous_key(std::string* buf_rendezvous_key);
4700   private:
4701   const std::string& _internal_buf_rendezvous_key() const;
4702   inline PROTOBUF_ALWAYS_INLINE void _internal_set_buf_rendezvous_key(const std::string& value);
4703   std::string* _internal_mutable_buf_rendezvous_key();
4704   public:
4705 
4706   // string src_device = 8;
4707   void clear_src_device();
4708   const std::string& src_device() const;
4709   template <typename ArgT0 = const std::string&, typename... ArgT>
4710   void set_src_device(ArgT0&& arg0, ArgT... args);
4711   std::string* mutable_src_device();
4712   PROTOBUF_NODISCARD std::string* release_src_device();
4713   void set_allocated_src_device(std::string* src_device);
4714   private:
4715   const std::string& _internal_src_device() const;
4716   inline PROTOBUF_ALWAYS_INLINE void _internal_set_src_device(const std::string& value);
4717   std::string* _internal_mutable_src_device();
4718   public:
4719 
4720   // string dst_device = 9;
4721   void clear_dst_device();
4722   const std::string& dst_device() const;
4723   template <typename ArgT0 = const std::string&, typename... ArgT>
4724   void set_dst_device(ArgT0&& arg0, ArgT... args);
4725   std::string* mutable_dst_device();
4726   PROTOBUF_NODISCARD std::string* release_dst_device();
4727   void set_allocated_dst_device(std::string* dst_device);
4728   private:
4729   const std::string& _internal_dst_device() const;
4730   inline PROTOBUF_ALWAYS_INLINE void _internal_set_dst_device(const std::string& value);
4731   std::string* _internal_mutable_dst_device();
4732   public:
4733 
4734   // .tensorflow.DeviceLocality client_locality = 5;
4735   bool has_client_locality() const;
4736   private:
4737   bool _internal_has_client_locality() const;
4738   public:
4739   void clear_client_locality();
4740   const ::tensorflow::DeviceLocality& client_locality() const;
4741   PROTOBUF_NODISCARD ::tensorflow::DeviceLocality* release_client_locality();
4742   ::tensorflow::DeviceLocality* mutable_client_locality();
4743   void set_allocated_client_locality(::tensorflow::DeviceLocality* client_locality);
4744   private:
4745   const ::tensorflow::DeviceLocality& _internal_client_locality() const;
4746   ::tensorflow::DeviceLocality* _internal_mutable_client_locality();
4747   public:
4748   void unsafe_arena_set_allocated_client_locality(
4749       ::tensorflow::DeviceLocality* client_locality);
4750   ::tensorflow::DeviceLocality* unsafe_arena_release_client_locality();
4751 
4752   // .tensorflow.DeviceLocality server_locality = 6;
4753   bool has_server_locality() const;
4754   private:
4755   bool _internal_has_server_locality() const;
4756   public:
4757   void clear_server_locality();
4758   const ::tensorflow::DeviceLocality& server_locality() const;
4759   PROTOBUF_NODISCARD ::tensorflow::DeviceLocality* release_server_locality();
4760   ::tensorflow::DeviceLocality* mutable_server_locality();
4761   void set_allocated_server_locality(::tensorflow::DeviceLocality* server_locality);
4762   private:
4763   const ::tensorflow::DeviceLocality& _internal_server_locality() const;
4764   ::tensorflow::DeviceLocality* _internal_mutable_server_locality();
4765   public:
4766   void unsafe_arena_set_allocated_server_locality(
4767       ::tensorflow::DeviceLocality* server_locality);
4768   ::tensorflow::DeviceLocality* unsafe_arena_release_server_locality();
4769 
4770   // .google.protobuf.Any transport_options = 7;
4771   bool has_transport_options() const;
4772   private:
4773   bool _internal_has_transport_options() const;
4774   public:
4775   void clear_transport_options();
4776   const ::PROTOBUF_NAMESPACE_ID::Any& transport_options() const;
4777   PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_transport_options();
4778   ::PROTOBUF_NAMESPACE_ID::Any* mutable_transport_options();
4779   void set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options);
4780   private:
4781   const ::PROTOBUF_NAMESPACE_ID::Any& _internal_transport_options() const;
4782   ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_transport_options();
4783   public:
4784   void unsafe_arena_set_allocated_transport_options(
4785       ::PROTOBUF_NAMESPACE_ID::Any* transport_options);
4786   ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_transport_options();
4787 
4788   // int64 step_id = 1;
4789   void clear_step_id();
4790   ::int64_t step_id() const;
4791   void set_step_id(::int64_t value);
4792   private:
4793   ::int64_t _internal_step_id() const;
4794   void _internal_set_step_id(::int64_t value);
4795   public:
4796 
4797   // int64 num_bytes = 3;
4798   void clear_num_bytes();
4799   ::int64_t num_bytes() const;
4800   void set_num_bytes(::int64_t value);
4801   private:
4802   ::int64_t _internal_num_bytes() const;
4803   void _internal_set_num_bytes(::int64_t value);
4804   public:
4805 
4806   // fixed64 buf_ptr = 4;
4807   void clear_buf_ptr();
4808   ::uint64_t buf_ptr() const;
4809   void set_buf_ptr(::uint64_t value);
4810   private:
4811   ::uint64_t _internal_buf_ptr() const;
4812   void _internal_set_buf_ptr(::uint64_t value);
4813   public:
4814 
4815   // int64 request_id = 10;
4816   void clear_request_id();
4817   ::int64_t request_id() const;
4818   void set_request_id(::int64_t value);
4819   private:
4820   ::int64_t _internal_request_id() const;
4821   void _internal_set_request_id(::int64_t value);
4822   public:
4823 
4824   // uint64 src_incarnation = 11;
4825   void clear_src_incarnation();
4826   ::uint64_t src_incarnation() const;
4827   void set_src_incarnation(::uint64_t value);
4828   private:
4829   ::uint64_t _internal_src_incarnation() const;
4830   void _internal_set_src_incarnation(::uint64_t value);
4831   public:
4832 
4833   // @@protoc_insertion_point(class_scope:tensorflow.RecvBufRequest)
4834  private:
4835   class _Internal;
4836 
4837   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
4838   typedef void InternalArenaConstructable_;
4839   typedef void DestructorSkippable_;
4840   struct Impl_ {
4841     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr buf_rendezvous_key_;
4842     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr src_device_;
4843     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dst_device_;
4844     ::tensorflow::DeviceLocality* client_locality_;
4845     ::tensorflow::DeviceLocality* server_locality_;
4846     ::PROTOBUF_NAMESPACE_ID::Any* transport_options_;
4847     ::int64_t step_id_;
4848     ::int64_t num_bytes_;
4849     ::uint64_t buf_ptr_;
4850     ::int64_t request_id_;
4851     ::uint64_t src_incarnation_;
4852     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
4853   };
4854   union { Impl_ _impl_; };
4855   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
4856 };
4857 // -------------------------------------------------------------------
4858 
4859 class RecvBufResponse final :
4860     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RecvBufResponse) */ {
4861  public:
RecvBufResponse()4862   inline RecvBufResponse() : RecvBufResponse(nullptr) {}
4863   ~RecvBufResponse() override;
4864   explicit PROTOBUF_CONSTEXPR RecvBufResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
4865 
4866   RecvBufResponse(const RecvBufResponse& from);
RecvBufResponse(RecvBufResponse && from)4867   RecvBufResponse(RecvBufResponse&& from) noexcept
4868     : RecvBufResponse() {
4869     *this = ::std::move(from);
4870   }
4871 
4872   inline RecvBufResponse& operator=(const RecvBufResponse& from) {
4873     if (this == &from) return *this;
4874     CopyFrom(from);
4875     return *this;
4876   }
4877   inline RecvBufResponse& operator=(RecvBufResponse&& from) noexcept {
4878     if (this == &from) return *this;
4879     if (GetOwningArena() == from.GetOwningArena()
4880   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
4881         && GetOwningArena() != nullptr
4882   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
4883     ) {
4884       InternalSwap(&from);
4885     } else {
4886       CopyFrom(from);
4887     }
4888     return *this;
4889   }
4890 
default_instance()4891   static const RecvBufResponse& default_instance() {
4892     return *internal_default_instance();
4893   }
internal_default_instance()4894   static inline const RecvBufResponse* internal_default_instance() {
4895     return reinterpret_cast<const RecvBufResponse*>(
4896                &_RecvBufResponse_default_instance_);
4897   }
4898   static constexpr int kIndexInFileMessages =
4899     28;
4900 
swap(RecvBufResponse & a,RecvBufResponse & b)4901   friend void swap(RecvBufResponse& a, RecvBufResponse& b) {
4902     a.Swap(&b);
4903   }
Swap(RecvBufResponse * other)4904   inline void Swap(RecvBufResponse* other) {
4905     if (other == this) return;
4906   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
4907     if (GetOwningArena() != nullptr &&
4908         GetOwningArena() == other->GetOwningArena()) {
4909    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
4910     if (GetOwningArena() == other->GetOwningArena()) {
4911   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
4912       InternalSwap(other);
4913     } else {
4914       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
4915     }
4916   }
4917   void UnsafeArenaSwap(RecvBufResponse* other) {
4918     if (other == this) return;
4919     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
4920     InternalSwap(other);
4921   }
4922 
4923   // implements Message ----------------------------------------------
4924 
4925   RecvBufResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
4926     return CreateMaybeMessage<RecvBufResponse>(arena);
4927   }
4928   RecvBufResponse* New() const {
4929     return New(nullptr);
4930   }
4931   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
4932   void CopyFrom(const RecvBufResponse& from);
4933   void MergeFrom(const RecvBufResponse& from);
4934   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
4935   bool IsInitialized() const final;
4936 
4937   size_t ByteSizeLong() const final;
4938   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
4939   ::uint8_t* _InternalSerialize(
4940       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
4941   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
4942 
4943   private:
4944   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
4945   void SharedDtor();
4946   void SetCachedSize(int size) const;
4947   void InternalSwap(RecvBufResponse* other);
4948 
4949   private:
4950   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
4951   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
4952     return "tensorflow.RecvBufResponse";
4953   }
4954   protected:
4955   explicit RecvBufResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4956                        bool is_message_owned = false);
4957   public:
4958 
4959   std::string GetTypeName() const final;
4960 
4961   // nested types ----------------------------------------------------
4962 
4963   // accessors -------------------------------------------------------
4964 
4965   enum : int {
4966     kTransportOptionsFieldNumber = 4,
4967     kBufPtrFieldNumber = 1,
4968     kNumBytesFieldNumber = 2,
4969     kSendStartMicrosFieldNumber = 5,
4970     kIsDeadFieldNumber = 3,
4971     kRequireAckFieldNumber = 6,
4972   };
4973   // .google.protobuf.Any transport_options = 4;
4974   bool has_transport_options() const;
4975   private:
4976   bool _internal_has_transport_options() const;
4977   public:
4978   void clear_transport_options();
4979   const ::PROTOBUF_NAMESPACE_ID::Any& transport_options() const;
4980   PROTOBUF_NODISCARD ::PROTOBUF_NAMESPACE_ID::Any* release_transport_options();
4981   ::PROTOBUF_NAMESPACE_ID::Any* mutable_transport_options();
4982   void set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options);
4983   private:
4984   const ::PROTOBUF_NAMESPACE_ID::Any& _internal_transport_options() const;
4985   ::PROTOBUF_NAMESPACE_ID::Any* _internal_mutable_transport_options();
4986   public:
4987   void unsafe_arena_set_allocated_transport_options(
4988       ::PROTOBUF_NAMESPACE_ID::Any* transport_options);
4989   ::PROTOBUF_NAMESPACE_ID::Any* unsafe_arena_release_transport_options();
4990 
4991   // fixed64 buf_ptr = 1;
4992   void clear_buf_ptr();
4993   ::uint64_t buf_ptr() const;
4994   void set_buf_ptr(::uint64_t value);
4995   private:
4996   ::uint64_t _internal_buf_ptr() const;
4997   void _internal_set_buf_ptr(::uint64_t value);
4998   public:
4999 
5000   // int64 num_bytes = 2;
5001   void clear_num_bytes();
5002   ::int64_t num_bytes() const;
5003   void set_num_bytes(::int64_t value);
5004   private:
5005   ::int64_t _internal_num_bytes() const;
5006   void _internal_set_num_bytes(::int64_t value);
5007   public:
5008 
5009   // int64 send_start_micros = 5;
5010   void clear_send_start_micros();
5011   ::int64_t send_start_micros() const;
5012   void set_send_start_micros(::int64_t value);
5013   private:
5014   ::int64_t _internal_send_start_micros() const;
5015   void _internal_set_send_start_micros(::int64_t value);
5016   public:
5017 
5018   // bool is_dead = 3;
5019   void clear_is_dead();
5020   bool is_dead() const;
5021   void set_is_dead(bool value);
5022   private:
5023   bool _internal_is_dead() const;
5024   void _internal_set_is_dead(bool value);
5025   public:
5026 
5027   // bool require_ack = 6;
5028   void clear_require_ack();
5029   bool require_ack() const;
5030   void set_require_ack(bool value);
5031   private:
5032   bool _internal_require_ack() const;
5033   void _internal_set_require_ack(bool value);
5034   public:
5035 
5036   // @@protoc_insertion_point(class_scope:tensorflow.RecvBufResponse)
5037  private:
5038   class _Internal;
5039 
5040   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5041   typedef void InternalArenaConstructable_;
5042   typedef void DestructorSkippable_;
5043   struct Impl_ {
5044     ::PROTOBUF_NAMESPACE_ID::Any* transport_options_;
5045     ::uint64_t buf_ptr_;
5046     ::int64_t num_bytes_;
5047     ::int64_t send_start_micros_;
5048     bool is_dead_;
5049     bool require_ack_;
5050     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5051   };
5052   union { Impl_ _impl_; };
5053   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
5054 };
5055 // -------------------------------------------------------------------
5056 
5057 class CompleteGroupRequest final :
5058     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CompleteGroupRequest) */ {
5059  public:
CompleteGroupRequest()5060   inline CompleteGroupRequest() : CompleteGroupRequest(nullptr) {}
5061   ~CompleteGroupRequest() override;
5062   explicit PROTOBUF_CONSTEXPR CompleteGroupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
5063 
5064   CompleteGroupRequest(const CompleteGroupRequest& from);
CompleteGroupRequest(CompleteGroupRequest && from)5065   CompleteGroupRequest(CompleteGroupRequest&& from) noexcept
5066     : CompleteGroupRequest() {
5067     *this = ::std::move(from);
5068   }
5069 
5070   inline CompleteGroupRequest& operator=(const CompleteGroupRequest& from) {
5071     if (this == &from) return *this;
5072     CopyFrom(from);
5073     return *this;
5074   }
5075   inline CompleteGroupRequest& operator=(CompleteGroupRequest&& from) noexcept {
5076     if (this == &from) return *this;
5077     if (GetOwningArena() == from.GetOwningArena()
5078   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5079         && GetOwningArena() != nullptr
5080   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5081     ) {
5082       InternalSwap(&from);
5083     } else {
5084       CopyFrom(from);
5085     }
5086     return *this;
5087   }
5088 
default_instance()5089   static const CompleteGroupRequest& default_instance() {
5090     return *internal_default_instance();
5091   }
internal_default_instance()5092   static inline const CompleteGroupRequest* internal_default_instance() {
5093     return reinterpret_cast<const CompleteGroupRequest*>(
5094                &_CompleteGroupRequest_default_instance_);
5095   }
5096   static constexpr int kIndexInFileMessages =
5097     29;
5098 
swap(CompleteGroupRequest & a,CompleteGroupRequest & b)5099   friend void swap(CompleteGroupRequest& a, CompleteGroupRequest& b) {
5100     a.Swap(&b);
5101   }
Swap(CompleteGroupRequest * other)5102   inline void Swap(CompleteGroupRequest* other) {
5103     if (other == this) return;
5104   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5105     if (GetOwningArena() != nullptr &&
5106         GetOwningArena() == other->GetOwningArena()) {
5107    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
5108     if (GetOwningArena() == other->GetOwningArena()) {
5109   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5110       InternalSwap(other);
5111     } else {
5112       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5113     }
5114   }
5115   void UnsafeArenaSwap(CompleteGroupRequest* other) {
5116     if (other == this) return;
5117     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
5118     InternalSwap(other);
5119   }
5120 
5121   // implements Message ----------------------------------------------
5122 
5123   CompleteGroupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5124     return CreateMaybeMessage<CompleteGroupRequest>(arena);
5125   }
5126   CompleteGroupRequest* New() const {
5127     return New(nullptr);
5128   }
5129   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
5130   void CopyFrom(const CompleteGroupRequest& from);
5131   void MergeFrom(const CompleteGroupRequest& from);
5132   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5133   bool IsInitialized() const final;
5134 
5135   size_t ByteSizeLong() const final;
5136   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5137   ::uint8_t* _InternalSerialize(
5138       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5139   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
5140 
5141   private:
5142   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
5143   void SharedDtor();
5144   void SetCachedSize(int size) const;
5145   void InternalSwap(CompleteGroupRequest* other);
5146 
5147   private:
5148   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5149   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5150     return "tensorflow.CompleteGroupRequest";
5151   }
5152   protected:
5153   explicit CompleteGroupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5154                        bool is_message_owned = false);
5155   public:
5156 
5157   std::string GetTypeName() const final;
5158 
5159   // nested types ----------------------------------------------------
5160 
5161   // accessors -------------------------------------------------------
5162 
5163   enum : int {
5164     kDeviceTypeFieldNumber = 3,
5165     kDeviceAttributesFieldNumber = 6,
5166     kGroupKeyFieldNumber = 1,
5167     kGroupSizeFieldNumber = 2,
5168     kCollectiveTypeFieldNumber = 5,
5169   };
5170   // string device_type = 3;
5171   void clear_device_type();
5172   const std::string& device_type() const;
5173   template <typename ArgT0 = const std::string&, typename... ArgT>
5174   void set_device_type(ArgT0&& arg0, ArgT... args);
5175   std::string* mutable_device_type();
5176   PROTOBUF_NODISCARD std::string* release_device_type();
5177   void set_allocated_device_type(std::string* device_type);
5178   private:
5179   const std::string& _internal_device_type() const;
5180   inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
5181   std::string* _internal_mutable_device_type();
5182   public:
5183 
5184   // .tensorflow.DeviceAttributes device_attributes = 6;
5185   bool has_device_attributes() const;
5186   private:
5187   bool _internal_has_device_attributes() const;
5188   public:
5189   void clear_device_attributes();
5190   const ::tensorflow::DeviceAttributes& device_attributes() const;
5191   PROTOBUF_NODISCARD ::tensorflow::DeviceAttributes* release_device_attributes();
5192   ::tensorflow::DeviceAttributes* mutable_device_attributes();
5193   void set_allocated_device_attributes(::tensorflow::DeviceAttributes* device_attributes);
5194   private:
5195   const ::tensorflow::DeviceAttributes& _internal_device_attributes() const;
5196   ::tensorflow::DeviceAttributes* _internal_mutable_device_attributes();
5197   public:
5198   void unsafe_arena_set_allocated_device_attributes(
5199       ::tensorflow::DeviceAttributes* device_attributes);
5200   ::tensorflow::DeviceAttributes* unsafe_arena_release_device_attributes();
5201 
5202   // int32 group_key = 1;
5203   void clear_group_key();
5204   ::int32_t group_key() const;
5205   void set_group_key(::int32_t value);
5206   private:
5207   ::int32_t _internal_group_key() const;
5208   void _internal_set_group_key(::int32_t value);
5209   public:
5210 
5211   // int32 group_size = 2;
5212   void clear_group_size();
5213   ::int32_t group_size() const;
5214   void set_group_size(::int32_t value);
5215   private:
5216   ::int32_t _internal_group_size() const;
5217   void _internal_set_group_size(::int32_t value);
5218   public:
5219 
5220   // int32 collective_type = 5;
5221   void clear_collective_type();
5222   ::int32_t collective_type() const;
5223   void set_collective_type(::int32_t value);
5224   private:
5225   ::int32_t _internal_collective_type() const;
5226   void _internal_set_collective_type(::int32_t value);
5227   public:
5228 
5229   // @@protoc_insertion_point(class_scope:tensorflow.CompleteGroupRequest)
5230  private:
5231   class _Internal;
5232 
5233   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5234   typedef void InternalArenaConstructable_;
5235   typedef void DestructorSkippable_;
5236   struct Impl_ {
5237     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
5238     ::tensorflow::DeviceAttributes* device_attributes_;
5239     ::int32_t group_key_;
5240     ::int32_t group_size_;
5241     ::int32_t collective_type_;
5242     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5243   };
5244   union { Impl_ _impl_; };
5245   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
5246 };
5247 // -------------------------------------------------------------------
5248 
5249 class CompleteGroupResponse final :
5250     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CompleteGroupResponse) */ {
5251  public:
CompleteGroupResponse()5252   inline CompleteGroupResponse() : CompleteGroupResponse(nullptr) {}
5253   ~CompleteGroupResponse() override;
5254   explicit PROTOBUF_CONSTEXPR CompleteGroupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
5255 
5256   CompleteGroupResponse(const CompleteGroupResponse& from);
CompleteGroupResponse(CompleteGroupResponse && from)5257   CompleteGroupResponse(CompleteGroupResponse&& from) noexcept
5258     : CompleteGroupResponse() {
5259     *this = ::std::move(from);
5260   }
5261 
5262   inline CompleteGroupResponse& operator=(const CompleteGroupResponse& from) {
5263     if (this == &from) return *this;
5264     CopyFrom(from);
5265     return *this;
5266   }
5267   inline CompleteGroupResponse& operator=(CompleteGroupResponse&& from) noexcept {
5268     if (this == &from) return *this;
5269     if (GetOwningArena() == from.GetOwningArena()
5270   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5271         && GetOwningArena() != nullptr
5272   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5273     ) {
5274       InternalSwap(&from);
5275     } else {
5276       CopyFrom(from);
5277     }
5278     return *this;
5279   }
5280 
default_instance()5281   static const CompleteGroupResponse& default_instance() {
5282     return *internal_default_instance();
5283   }
internal_default_instance()5284   static inline const CompleteGroupResponse* internal_default_instance() {
5285     return reinterpret_cast<const CompleteGroupResponse*>(
5286                &_CompleteGroupResponse_default_instance_);
5287   }
5288   static constexpr int kIndexInFileMessages =
5289     30;
5290 
swap(CompleteGroupResponse & a,CompleteGroupResponse & b)5291   friend void swap(CompleteGroupResponse& a, CompleteGroupResponse& b) {
5292     a.Swap(&b);
5293   }
Swap(CompleteGroupResponse * other)5294   inline void Swap(CompleteGroupResponse* other) {
5295     if (other == this) return;
5296   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5297     if (GetOwningArena() != nullptr &&
5298         GetOwningArena() == other->GetOwningArena()) {
5299    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
5300     if (GetOwningArena() == other->GetOwningArena()) {
5301   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5302       InternalSwap(other);
5303     } else {
5304       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5305     }
5306   }
5307   void UnsafeArenaSwap(CompleteGroupResponse* other) {
5308     if (other == this) return;
5309     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
5310     InternalSwap(other);
5311   }
5312 
5313   // implements Message ----------------------------------------------
5314 
5315   CompleteGroupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5316     return CreateMaybeMessage<CompleteGroupResponse>(arena);
5317   }
5318   CompleteGroupResponse* New() const {
5319     return New(nullptr);
5320   }
5321   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
5322   void CopyFrom(const CompleteGroupResponse& from);
5323   void MergeFrom(const CompleteGroupResponse& from);
5324   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5325   bool IsInitialized() const final;
5326 
5327   size_t ByteSizeLong() const final;
5328   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5329   ::uint8_t* _InternalSerialize(
5330       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5331   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
5332 
5333   private:
5334   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
5335   void SharedDtor();
5336   void SetCachedSize(int size) const;
5337   void InternalSwap(CompleteGroupResponse* other);
5338 
5339   private:
5340   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5341   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5342     return "tensorflow.CompleteGroupResponse";
5343   }
5344   protected:
5345   explicit CompleteGroupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5346                        bool is_message_owned = false);
5347   public:
5348 
5349   std::string GetTypeName() const final;
5350 
5351   // nested types ----------------------------------------------------
5352 
5353   // accessors -------------------------------------------------------
5354 
5355   enum : int {
5356     kDeviceAttributesFieldNumber = 8,
5357     kDeviceTypeFieldNumber = 3,
5358     kCommunicatorKeyFieldNumber = 7,
5359     kGroupKeyFieldNumber = 1,
5360     kGroupSizeFieldNumber = 2,
5361     kNumTasksFieldNumber = 4,
5362   };
5363   // repeated .tensorflow.DeviceAttributes device_attributes = 8;
5364   int device_attributes_size() const;
5365   private:
5366   int _internal_device_attributes_size() const;
5367   public:
5368   void clear_device_attributes();
5369   ::tensorflow::DeviceAttributes* mutable_device_attributes(int index);
5370   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
5371       mutable_device_attributes();
5372   private:
5373   const ::tensorflow::DeviceAttributes& _internal_device_attributes(int index) const;
5374   ::tensorflow::DeviceAttributes* _internal_add_device_attributes();
5375   public:
5376   const ::tensorflow::DeviceAttributes& device_attributes(int index) const;
5377   ::tensorflow::DeviceAttributes* add_device_attributes();
5378   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
5379       device_attributes() const;
5380 
5381   // string device_type = 3;
5382   void clear_device_type();
5383   const std::string& device_type() const;
5384   template <typename ArgT0 = const std::string&, typename... ArgT>
5385   void set_device_type(ArgT0&& arg0, ArgT... args);
5386   std::string* mutable_device_type();
5387   PROTOBUF_NODISCARD std::string* release_device_type();
5388   void set_allocated_device_type(std::string* device_type);
5389   private:
5390   const std::string& _internal_device_type() const;
5391   inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
5392   std::string* _internal_mutable_device_type();
5393   public:
5394 
5395   // bytes communicator_key = 7;
5396   void clear_communicator_key();
5397   const std::string& communicator_key() const;
5398   template <typename ArgT0 = const std::string&, typename... ArgT>
5399   void set_communicator_key(ArgT0&& arg0, ArgT... args);
5400   std::string* mutable_communicator_key();
5401   PROTOBUF_NODISCARD std::string* release_communicator_key();
5402   void set_allocated_communicator_key(std::string* communicator_key);
5403   private:
5404   const std::string& _internal_communicator_key() const;
5405   inline PROTOBUF_ALWAYS_INLINE void _internal_set_communicator_key(const std::string& value);
5406   std::string* _internal_mutable_communicator_key();
5407   public:
5408 
5409   // int32 group_key = 1;
5410   void clear_group_key();
5411   ::int32_t group_key() const;
5412   void set_group_key(::int32_t value);
5413   private:
5414   ::int32_t _internal_group_key() const;
5415   void _internal_set_group_key(::int32_t value);
5416   public:
5417 
5418   // int32 group_size = 2;
5419   void clear_group_size();
5420   ::int32_t group_size() const;
5421   void set_group_size(::int32_t value);
5422   private:
5423   ::int32_t _internal_group_size() const;
5424   void _internal_set_group_size(::int32_t value);
5425   public:
5426 
5427   // int32 num_tasks = 4;
5428   void clear_num_tasks();
5429   ::int32_t num_tasks() const;
5430   void set_num_tasks(::int32_t value);
5431   private:
5432   ::int32_t _internal_num_tasks() const;
5433   void _internal_set_num_tasks(::int32_t value);
5434   public:
5435 
5436   // @@protoc_insertion_point(class_scope:tensorflow.CompleteGroupResponse)
5437  private:
5438   class _Internal;
5439 
5440   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5441   typedef void InternalArenaConstructable_;
5442   typedef void DestructorSkippable_;
5443   struct Impl_ {
5444     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes > device_attributes_;
5445     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
5446     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr communicator_key_;
5447     ::int32_t group_key_;
5448     ::int32_t group_size_;
5449     ::int32_t num_tasks_;
5450     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5451   };
5452   union { Impl_ _impl_; };
5453   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
5454 };
5455 // -------------------------------------------------------------------
5456 
5457 class CompleteInstanceRequest final :
5458     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CompleteInstanceRequest) */ {
5459  public:
CompleteInstanceRequest()5460   inline CompleteInstanceRequest() : CompleteInstanceRequest(nullptr) {}
5461   ~CompleteInstanceRequest() override;
5462   explicit PROTOBUF_CONSTEXPR CompleteInstanceRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
5463 
5464   CompleteInstanceRequest(const CompleteInstanceRequest& from);
CompleteInstanceRequest(CompleteInstanceRequest && from)5465   CompleteInstanceRequest(CompleteInstanceRequest&& from) noexcept
5466     : CompleteInstanceRequest() {
5467     *this = ::std::move(from);
5468   }
5469 
5470   inline CompleteInstanceRequest& operator=(const CompleteInstanceRequest& from) {
5471     if (this == &from) return *this;
5472     CopyFrom(from);
5473     return *this;
5474   }
5475   inline CompleteInstanceRequest& operator=(CompleteInstanceRequest&& from) noexcept {
5476     if (this == &from) return *this;
5477     if (GetOwningArena() == from.GetOwningArena()
5478   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5479         && GetOwningArena() != nullptr
5480   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5481     ) {
5482       InternalSwap(&from);
5483     } else {
5484       CopyFrom(from);
5485     }
5486     return *this;
5487   }
5488 
default_instance()5489   static const CompleteInstanceRequest& default_instance() {
5490     return *internal_default_instance();
5491   }
internal_default_instance()5492   static inline const CompleteInstanceRequest* internal_default_instance() {
5493     return reinterpret_cast<const CompleteInstanceRequest*>(
5494                &_CompleteInstanceRequest_default_instance_);
5495   }
5496   static constexpr int kIndexInFileMessages =
5497     31;
5498 
swap(CompleteInstanceRequest & a,CompleteInstanceRequest & b)5499   friend void swap(CompleteInstanceRequest& a, CompleteInstanceRequest& b) {
5500     a.Swap(&b);
5501   }
Swap(CompleteInstanceRequest * other)5502   inline void Swap(CompleteInstanceRequest* other) {
5503     if (other == this) return;
5504   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5505     if (GetOwningArena() != nullptr &&
5506         GetOwningArena() == other->GetOwningArena()) {
5507    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
5508     if (GetOwningArena() == other->GetOwningArena()) {
5509   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5510       InternalSwap(other);
5511     } else {
5512       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5513     }
5514   }
5515   void UnsafeArenaSwap(CompleteInstanceRequest* other) {
5516     if (other == this) return;
5517     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
5518     InternalSwap(other);
5519   }
5520 
5521   // implements Message ----------------------------------------------
5522 
5523   CompleteInstanceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5524     return CreateMaybeMessage<CompleteInstanceRequest>(arena);
5525   }
5526   CompleteInstanceRequest* New() const {
5527     return New(nullptr);
5528   }
5529   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
5530   void CopyFrom(const CompleteInstanceRequest& from);
5531   void MergeFrom(const CompleteInstanceRequest& from);
5532   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5533   bool IsInitialized() const final;
5534 
5535   size_t ByteSizeLong() const final;
5536   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5537   ::uint8_t* _InternalSerialize(
5538       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5539   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
5540 
5541   private:
5542   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
5543   void SharedDtor();
5544   void SetCachedSize(int size) const;
5545   void InternalSwap(CompleteInstanceRequest* other);
5546 
5547   private:
5548   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5549   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5550     return "tensorflow.CompleteInstanceRequest";
5551   }
5552   protected:
5553   explicit CompleteInstanceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5554                        bool is_message_owned = false);
5555   public:
5556 
5557   std::string GetTypeName() const final;
5558 
5559   // nested types ----------------------------------------------------
5560 
5561   // accessors -------------------------------------------------------
5562 
5563   enum : int {
5564     kSubdivOffsetFieldNumber = 9,
5565     kNameFieldNumber = 1,
5566     kDeviceTypeFieldNumber = 8,
5567     kDeviceFieldNumber = 10,
5568     kShapeFieldNumber = 4,
5569     kTypeFieldNumber = 2,
5570     kDataTypeFieldNumber = 3,
5571     kGroupKeyFieldNumber = 5,
5572     kGroupSizeFieldNumber = 6,
5573     kInstanceKeyFieldNumber = 7,
5574     kIsSourceFieldNumber = 11,
5575   };
5576   // repeated int32 subdiv_offset = 9;
5577   int subdiv_offset_size() const;
5578   private:
5579   int _internal_subdiv_offset_size() const;
5580   public:
5581   void clear_subdiv_offset();
5582   private:
5583   ::int32_t _internal_subdiv_offset(int index) const;
5584   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
5585       _internal_subdiv_offset() const;
5586   void _internal_add_subdiv_offset(::int32_t value);
5587   ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
5588       _internal_mutable_subdiv_offset();
5589   public:
5590   ::int32_t subdiv_offset(int index) const;
5591   void set_subdiv_offset(int index, ::int32_t value);
5592   void add_subdiv_offset(::int32_t value);
5593   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
5594       subdiv_offset() const;
5595   ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
5596       mutable_subdiv_offset();
5597 
5598   // string name = 1;
5599   void clear_name();
5600   const std::string& name() const;
5601   template <typename ArgT0 = const std::string&, typename... ArgT>
5602   void set_name(ArgT0&& arg0, ArgT... args);
5603   std::string* mutable_name();
5604   PROTOBUF_NODISCARD std::string* release_name();
5605   void set_allocated_name(std::string* name);
5606   private:
5607   const std::string& _internal_name() const;
5608   inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
5609   std::string* _internal_mutable_name();
5610   public:
5611 
5612   // string device_type = 8;
5613   void clear_device_type();
5614   const std::string& device_type() const;
5615   template <typename ArgT0 = const std::string&, typename... ArgT>
5616   void set_device_type(ArgT0&& arg0, ArgT... args);
5617   std::string* mutable_device_type();
5618   PROTOBUF_NODISCARD std::string* release_device_type();
5619   void set_allocated_device_type(std::string* device_type);
5620   private:
5621   const std::string& _internal_device_type() const;
5622   inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
5623   std::string* _internal_mutable_device_type();
5624   public:
5625 
5626   // string device = 10;
5627   void clear_device();
5628   const std::string& device() const;
5629   template <typename ArgT0 = const std::string&, typename... ArgT>
5630   void set_device(ArgT0&& arg0, ArgT... args);
5631   std::string* mutable_device();
5632   PROTOBUF_NODISCARD std::string* release_device();
5633   void set_allocated_device(std::string* device);
5634   private:
5635   const std::string& _internal_device() const;
5636   inline PROTOBUF_ALWAYS_INLINE void _internal_set_device(const std::string& value);
5637   std::string* _internal_mutable_device();
5638   public:
5639 
5640   // .tensorflow.TensorShapeProto shape = 4;
5641   bool has_shape() const;
5642   private:
5643   bool _internal_has_shape() const;
5644   public:
5645   void clear_shape();
5646   const ::tensorflow::TensorShapeProto& shape() const;
5647   PROTOBUF_NODISCARD ::tensorflow::TensorShapeProto* release_shape();
5648   ::tensorflow::TensorShapeProto* mutable_shape();
5649   void set_allocated_shape(::tensorflow::TensorShapeProto* shape);
5650   private:
5651   const ::tensorflow::TensorShapeProto& _internal_shape() const;
5652   ::tensorflow::TensorShapeProto* _internal_mutable_shape();
5653   public:
5654   void unsafe_arena_set_allocated_shape(
5655       ::tensorflow::TensorShapeProto* shape);
5656   ::tensorflow::TensorShapeProto* unsafe_arena_release_shape();
5657 
5658   // int32 type = 2;
5659   void clear_type();
5660   ::int32_t type() const;
5661   void set_type(::int32_t value);
5662   private:
5663   ::int32_t _internal_type() const;
5664   void _internal_set_type(::int32_t value);
5665   public:
5666 
5667   // .tensorflow.DataType data_type = 3;
5668   void clear_data_type();
5669   ::tensorflow::DataType data_type() const;
5670   void set_data_type(::tensorflow::DataType value);
5671   private:
5672   ::tensorflow::DataType _internal_data_type() const;
5673   void _internal_set_data_type(::tensorflow::DataType value);
5674   public:
5675 
5676   // int32 group_key = 5;
5677   void clear_group_key();
5678   ::int32_t group_key() const;
5679   void set_group_key(::int32_t value);
5680   private:
5681   ::int32_t _internal_group_key() const;
5682   void _internal_set_group_key(::int32_t value);
5683   public:
5684 
5685   // int32 group_size = 6;
5686   void clear_group_size();
5687   ::int32_t group_size() const;
5688   void set_group_size(::int32_t value);
5689   private:
5690   ::int32_t _internal_group_size() const;
5691   void _internal_set_group_size(::int32_t value);
5692   public:
5693 
5694   // int32 instance_key = 7;
5695   void clear_instance_key();
5696   ::int32_t instance_key() const;
5697   void set_instance_key(::int32_t value);
5698   private:
5699   ::int32_t _internal_instance_key() const;
5700   void _internal_set_instance_key(::int32_t value);
5701   public:
5702 
5703   // bool is_source = 11;
5704   void clear_is_source();
5705   bool is_source() const;
5706   void set_is_source(bool value);
5707   private:
5708   bool _internal_is_source() const;
5709   void _internal_set_is_source(bool value);
5710   public:
5711 
5712   // @@protoc_insertion_point(class_scope:tensorflow.CompleteInstanceRequest)
5713  private:
5714   class _Internal;
5715 
5716   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5717   typedef void InternalArenaConstructable_;
5718   typedef void DestructorSkippable_;
5719   struct Impl_ {
5720     ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t > subdiv_offset_;
5721     mutable std::atomic<int> _subdiv_offset_cached_byte_size_;
5722     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
5723     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
5724     ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_;
5725     ::tensorflow::TensorShapeProto* shape_;
5726     ::int32_t type_;
5727     int data_type_;
5728     ::int32_t group_key_;
5729     ::int32_t group_size_;
5730     ::int32_t instance_key_;
5731     bool is_source_;
5732     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5733   };
5734   union { Impl_ _impl_; };
5735   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
5736 };
5737 // -------------------------------------------------------------------
5738 
5739 class CompleteInstanceResponse final :
5740     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CompleteInstanceResponse) */ {
5741  public:
CompleteInstanceResponse()5742   inline CompleteInstanceResponse() : CompleteInstanceResponse(nullptr) {}
5743   ~CompleteInstanceResponse() override;
5744   explicit PROTOBUF_CONSTEXPR CompleteInstanceResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
5745 
5746   CompleteInstanceResponse(const CompleteInstanceResponse& from);
CompleteInstanceResponse(CompleteInstanceResponse && from)5747   CompleteInstanceResponse(CompleteInstanceResponse&& from) noexcept
5748     : CompleteInstanceResponse() {
5749     *this = ::std::move(from);
5750   }
5751 
5752   inline CompleteInstanceResponse& operator=(const CompleteInstanceResponse& from) {
5753     if (this == &from) return *this;
5754     CopyFrom(from);
5755     return *this;
5756   }
5757   inline CompleteInstanceResponse& operator=(CompleteInstanceResponse&& from) noexcept {
5758     if (this == &from) return *this;
5759     if (GetOwningArena() == from.GetOwningArena()
5760   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5761         && GetOwningArena() != nullptr
5762   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5763     ) {
5764       InternalSwap(&from);
5765     } else {
5766       CopyFrom(from);
5767     }
5768     return *this;
5769   }
5770 
default_instance()5771   static const CompleteInstanceResponse& default_instance() {
5772     return *internal_default_instance();
5773   }
internal_default_instance()5774   static inline const CompleteInstanceResponse* internal_default_instance() {
5775     return reinterpret_cast<const CompleteInstanceResponse*>(
5776                &_CompleteInstanceResponse_default_instance_);
5777   }
5778   static constexpr int kIndexInFileMessages =
5779     32;
5780 
swap(CompleteInstanceResponse & a,CompleteInstanceResponse & b)5781   friend void swap(CompleteInstanceResponse& a, CompleteInstanceResponse& b) {
5782     a.Swap(&b);
5783   }
Swap(CompleteInstanceResponse * other)5784   inline void Swap(CompleteInstanceResponse* other) {
5785     if (other == this) return;
5786   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5787     if (GetOwningArena() != nullptr &&
5788         GetOwningArena() == other->GetOwningArena()) {
5789    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
5790     if (GetOwningArena() == other->GetOwningArena()) {
5791   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5792       InternalSwap(other);
5793     } else {
5794       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5795     }
5796   }
5797   void UnsafeArenaSwap(CompleteInstanceResponse* other) {
5798     if (other == this) return;
5799     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
5800     InternalSwap(other);
5801   }
5802 
5803   // implements Message ----------------------------------------------
5804 
5805   CompleteInstanceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5806     return CreateMaybeMessage<CompleteInstanceResponse>(arena);
5807   }
5808   CompleteInstanceResponse* New() const {
5809     return New(nullptr);
5810   }
5811   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
5812   void CopyFrom(const CompleteInstanceResponse& from);
5813   void MergeFrom(const CompleteInstanceResponse& from);
5814   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5815   bool IsInitialized() const final;
5816 
5817   size_t ByteSizeLong() const final;
5818   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5819   ::uint8_t* _InternalSerialize(
5820       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5821   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
5822 
5823   private:
5824   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
5825   void SharedDtor();
5826   void SetCachedSize(int size) const;
5827   void InternalSwap(CompleteInstanceResponse* other);
5828 
5829   private:
5830   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5831   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5832     return "tensorflow.CompleteInstanceResponse";
5833   }
5834   protected:
5835   explicit CompleteInstanceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5836                        bool is_message_owned = false);
5837   public:
5838 
5839   std::string GetTypeName() const final;
5840 
5841   // nested types ----------------------------------------------------
5842 
5843   // accessors -------------------------------------------------------
5844 
5845   enum : int {
5846     kInstanceKeyFieldNumber = 1,
5847     kSourceRankFieldNumber = 2,
5848   };
5849   // int32 instance_key = 1;
5850   void clear_instance_key();
5851   ::int32_t instance_key() const;
5852   void set_instance_key(::int32_t value);
5853   private:
5854   ::int32_t _internal_instance_key() const;
5855   void _internal_set_instance_key(::int32_t value);
5856   public:
5857 
5858   // int32 source_rank = 2;
5859   void clear_source_rank();
5860   ::int32_t source_rank() const;
5861   void set_source_rank(::int32_t value);
5862   private:
5863   ::int32_t _internal_source_rank() const;
5864   void _internal_set_source_rank(::int32_t value);
5865   public:
5866 
5867   // @@protoc_insertion_point(class_scope:tensorflow.CompleteInstanceResponse)
5868  private:
5869   class _Internal;
5870 
5871   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
5872   typedef void InternalArenaConstructable_;
5873   typedef void DestructorSkippable_;
5874   struct Impl_ {
5875     ::int32_t instance_key_;
5876     ::int32_t source_rank_;
5877     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
5878   };
5879   union { Impl_ _impl_; };
5880   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
5881 };
5882 // -------------------------------------------------------------------
5883 
5884 class GetStepSequenceRequest final :
5885     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.GetStepSequenceRequest) */ {
5886  public:
GetStepSequenceRequest()5887   inline GetStepSequenceRequest() : GetStepSequenceRequest(nullptr) {}
5888   ~GetStepSequenceRequest() override;
5889   explicit PROTOBUF_CONSTEXPR GetStepSequenceRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
5890 
5891   GetStepSequenceRequest(const GetStepSequenceRequest& from);
GetStepSequenceRequest(GetStepSequenceRequest && from)5892   GetStepSequenceRequest(GetStepSequenceRequest&& from) noexcept
5893     : GetStepSequenceRequest() {
5894     *this = ::std::move(from);
5895   }
5896 
5897   inline GetStepSequenceRequest& operator=(const GetStepSequenceRequest& from) {
5898     if (this == &from) return *this;
5899     CopyFrom(from);
5900     return *this;
5901   }
5902   inline GetStepSequenceRequest& operator=(GetStepSequenceRequest&& from) noexcept {
5903     if (this == &from) return *this;
5904     if (GetOwningArena() == from.GetOwningArena()
5905   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
5906         && GetOwningArena() != nullptr
5907   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
5908     ) {
5909       InternalSwap(&from);
5910     } else {
5911       CopyFrom(from);
5912     }
5913     return *this;
5914   }
5915 
default_instance()5916   static const GetStepSequenceRequest& default_instance() {
5917     return *internal_default_instance();
5918   }
internal_default_instance()5919   static inline const GetStepSequenceRequest* internal_default_instance() {
5920     return reinterpret_cast<const GetStepSequenceRequest*>(
5921                &_GetStepSequenceRequest_default_instance_);
5922   }
5923   static constexpr int kIndexInFileMessages =
5924     33;
5925 
swap(GetStepSequenceRequest & a,GetStepSequenceRequest & b)5926   friend void swap(GetStepSequenceRequest& a, GetStepSequenceRequest& b) {
5927     a.Swap(&b);
5928   }
Swap(GetStepSequenceRequest * other)5929   inline void Swap(GetStepSequenceRequest* other) {
5930     if (other == this) return;
5931   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
5932     if (GetOwningArena() != nullptr &&
5933         GetOwningArena() == other->GetOwningArena()) {
5934    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
5935     if (GetOwningArena() == other->GetOwningArena()) {
5936   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
5937       InternalSwap(other);
5938     } else {
5939       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
5940     }
5941   }
5942   void UnsafeArenaSwap(GetStepSequenceRequest* other) {
5943     if (other == this) return;
5944     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
5945     InternalSwap(other);
5946   }
5947 
5948   // implements Message ----------------------------------------------
5949 
5950   GetStepSequenceRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
5951     return CreateMaybeMessage<GetStepSequenceRequest>(arena);
5952   }
5953   GetStepSequenceRequest* New() const {
5954     return New(nullptr);
5955   }
5956   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
5957   void CopyFrom(const GetStepSequenceRequest& from);
5958   void MergeFrom(const GetStepSequenceRequest& from);
5959   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
5960   bool IsInitialized() const final;
5961 
5962   size_t ByteSizeLong() const final;
5963   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
5964   ::uint8_t* _InternalSerialize(
5965       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
5966   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
5967 
5968   private:
5969   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
5970   void SharedDtor();
5971   void SetCachedSize(int size) const;
5972   void InternalSwap(GetStepSequenceRequest* other);
5973 
5974   private:
5975   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
5976   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
5977     return "tensorflow.GetStepSequenceRequest";
5978   }
5979   protected:
5980   explicit GetStepSequenceRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5981                        bool is_message_owned = false);
5982   public:
5983 
5984   std::string GetTypeName() const final;
5985 
5986   // nested types ----------------------------------------------------
5987 
5988   // accessors -------------------------------------------------------
5989 
5990   enum : int {
5991     kGraphKeyFieldNumber = 1,
5992   };
5993   // repeated int64 graph_key = 1;
5994   int graph_key_size() const;
5995   private:
5996   int _internal_graph_key_size() const;
5997   public:
5998   void clear_graph_key();
5999   private:
6000   ::int64_t _internal_graph_key(int index) const;
6001   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
6002       _internal_graph_key() const;
6003   void _internal_add_graph_key(::int64_t value);
6004   ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
6005       _internal_mutable_graph_key();
6006   public:
6007   ::int64_t graph_key(int index) const;
6008   void set_graph_key(int index, ::int64_t value);
6009   void add_graph_key(::int64_t value);
6010   const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
6011       graph_key() const;
6012   ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
6013       mutable_graph_key();
6014 
6015   // @@protoc_insertion_point(class_scope:tensorflow.GetStepSequenceRequest)
6016  private:
6017   class _Internal;
6018 
6019   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
6020   typedef void InternalArenaConstructable_;
6021   typedef void DestructorSkippable_;
6022   struct Impl_ {
6023     ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t > graph_key_;
6024     mutable std::atomic<int> _graph_key_cached_byte_size_;
6025     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
6026   };
6027   union { Impl_ _impl_; };
6028   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
6029 };
6030 // -------------------------------------------------------------------
6031 
6032 class StepSequence final :
6033     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.StepSequence) */ {
6034  public:
StepSequence()6035   inline StepSequence() : StepSequence(nullptr) {}
6036   ~StepSequence() override;
6037   explicit PROTOBUF_CONSTEXPR StepSequence(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
6038 
6039   StepSequence(const StepSequence& from);
StepSequence(StepSequence && from)6040   StepSequence(StepSequence&& from) noexcept
6041     : StepSequence() {
6042     *this = ::std::move(from);
6043   }
6044 
6045   inline StepSequence& operator=(const StepSequence& from) {
6046     if (this == &from) return *this;
6047     CopyFrom(from);
6048     return *this;
6049   }
6050   inline StepSequence& operator=(StepSequence&& from) noexcept {
6051     if (this == &from) return *this;
6052     if (GetOwningArena() == from.GetOwningArena()
6053   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
6054         && GetOwningArena() != nullptr
6055   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
6056     ) {
6057       InternalSwap(&from);
6058     } else {
6059       CopyFrom(from);
6060     }
6061     return *this;
6062   }
6063 
default_instance()6064   static const StepSequence& default_instance() {
6065     return *internal_default_instance();
6066   }
internal_default_instance()6067   static inline const StepSequence* internal_default_instance() {
6068     return reinterpret_cast<const StepSequence*>(
6069                &_StepSequence_default_instance_);
6070   }
6071   static constexpr int kIndexInFileMessages =
6072     34;
6073 
swap(StepSequence & a,StepSequence & b)6074   friend void swap(StepSequence& a, StepSequence& b) {
6075     a.Swap(&b);
6076   }
Swap(StepSequence * other)6077   inline void Swap(StepSequence* other) {
6078     if (other == this) return;
6079   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
6080     if (GetOwningArena() != nullptr &&
6081         GetOwningArena() == other->GetOwningArena()) {
6082    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
6083     if (GetOwningArena() == other->GetOwningArena()) {
6084   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
6085       InternalSwap(other);
6086     } else {
6087       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
6088     }
6089   }
6090   void UnsafeArenaSwap(StepSequence* other) {
6091     if (other == this) return;
6092     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
6093     InternalSwap(other);
6094   }
6095 
6096   // implements Message ----------------------------------------------
6097 
6098   StepSequence* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
6099     return CreateMaybeMessage<StepSequence>(arena);
6100   }
6101   StepSequence* New() const {
6102     return New(nullptr);
6103   }
6104   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
6105   void CopyFrom(const StepSequence& from);
6106   void MergeFrom(const StepSequence& from);
6107   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
6108   bool IsInitialized() const final;
6109 
6110   size_t ByteSizeLong() const final;
6111   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
6112   ::uint8_t* _InternalSerialize(
6113       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
6114   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
6115 
6116   private:
6117   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
6118   void SharedDtor();
6119   void SetCachedSize(int size) const;
6120   void InternalSwap(StepSequence* other);
6121 
6122   private:
6123   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
6124   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
6125     return "tensorflow.StepSequence";
6126   }
6127   protected:
6128   explicit StepSequence(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6129                        bool is_message_owned = false);
6130   public:
6131 
6132   std::string GetTypeName() const final;
6133 
6134   // nested types ----------------------------------------------------
6135 
6136   // accessors -------------------------------------------------------
6137 
6138   enum : int {
6139     kGraphKeyFieldNumber = 1,
6140     kNextStepIdFieldNumber = 2,
6141   };
6142   // int64 graph_key = 1;
6143   void clear_graph_key();
6144   ::int64_t graph_key() const;
6145   void set_graph_key(::int64_t value);
6146   private:
6147   ::int64_t _internal_graph_key() const;
6148   void _internal_set_graph_key(::int64_t value);
6149   public:
6150 
6151   // int64 next_step_id = 2;
6152   void clear_next_step_id();
6153   ::int64_t next_step_id() const;
6154   void set_next_step_id(::int64_t value);
6155   private:
6156   ::int64_t _internal_next_step_id() const;
6157   void _internal_set_next_step_id(::int64_t value);
6158   public:
6159 
6160   // @@protoc_insertion_point(class_scope:tensorflow.StepSequence)
6161  private:
6162   class _Internal;
6163 
6164   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
6165   typedef void InternalArenaConstructable_;
6166   typedef void DestructorSkippable_;
6167   struct Impl_ {
6168     ::int64_t graph_key_;
6169     ::int64_t next_step_id_;
6170     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
6171   };
6172   union { Impl_ _impl_; };
6173   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
6174 };
6175 // -------------------------------------------------------------------
6176 
6177 class GetStepSequenceResponse final :
6178     public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.GetStepSequenceResponse) */ {
6179  public:
GetStepSequenceResponse()6180   inline GetStepSequenceResponse() : GetStepSequenceResponse(nullptr) {}
6181   ~GetStepSequenceResponse() override;
6182   explicit PROTOBUF_CONSTEXPR GetStepSequenceResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
6183 
6184   GetStepSequenceResponse(const GetStepSequenceResponse& from);
GetStepSequenceResponse(GetStepSequenceResponse && from)6185   GetStepSequenceResponse(GetStepSequenceResponse&& from) noexcept
6186     : GetStepSequenceResponse() {
6187     *this = ::std::move(from);
6188   }
6189 
6190   inline GetStepSequenceResponse& operator=(const GetStepSequenceResponse& from) {
6191     if (this == &from) return *this;
6192     CopyFrom(from);
6193     return *this;
6194   }
6195   inline GetStepSequenceResponse& operator=(GetStepSequenceResponse&& from) noexcept {
6196     if (this == &from) return *this;
6197     if (GetOwningArena() == from.GetOwningArena()
6198   #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
6199         && GetOwningArena() != nullptr
6200   #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
6201     ) {
6202       InternalSwap(&from);
6203     } else {
6204       CopyFrom(from);
6205     }
6206     return *this;
6207   }
6208 
default_instance()6209   static const GetStepSequenceResponse& default_instance() {
6210     return *internal_default_instance();
6211   }
internal_default_instance()6212   static inline const GetStepSequenceResponse* internal_default_instance() {
6213     return reinterpret_cast<const GetStepSequenceResponse*>(
6214                &_GetStepSequenceResponse_default_instance_);
6215   }
6216   static constexpr int kIndexInFileMessages =
6217     35;
6218 
swap(GetStepSequenceResponse & a,GetStepSequenceResponse & b)6219   friend void swap(GetStepSequenceResponse& a, GetStepSequenceResponse& b) {
6220     a.Swap(&b);
6221   }
Swap(GetStepSequenceResponse * other)6222   inline void Swap(GetStepSequenceResponse* other) {
6223     if (other == this) return;
6224   #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
6225     if (GetOwningArena() != nullptr &&
6226         GetOwningArena() == other->GetOwningArena()) {
6227    #else  // PROTOBUF_FORCE_COPY_IN_SWAP
6228     if (GetOwningArena() == other->GetOwningArena()) {
6229   #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
6230       InternalSwap(other);
6231     } else {
6232       ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
6233     }
6234   }
6235   void UnsafeArenaSwap(GetStepSequenceResponse* other) {
6236     if (other == this) return;
6237     GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
6238     InternalSwap(other);
6239   }
6240 
6241   // implements Message ----------------------------------------------
6242 
6243   GetStepSequenceResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
6244     return CreateMaybeMessage<GetStepSequenceResponse>(arena);
6245   }
6246   GetStepSequenceResponse* New() const {
6247     return New(nullptr);
6248   }
6249   void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
6250   void CopyFrom(const GetStepSequenceResponse& from);
6251   void MergeFrom(const GetStepSequenceResponse& from);
6252   PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
6253   bool IsInitialized() const final;
6254 
6255   size_t ByteSizeLong() const final;
6256   const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
6257   ::uint8_t* _InternalSerialize(
6258       ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
6259   int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
6260 
6261   private:
6262   void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
6263   void SharedDtor();
6264   void SetCachedSize(int size) const;
6265   void InternalSwap(GetStepSequenceResponse* other);
6266 
6267   private:
6268   friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
6269   static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
6270     return "tensorflow.GetStepSequenceResponse";
6271   }
6272   protected:
6273   explicit GetStepSequenceResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6274                        bool is_message_owned = false);
6275   public:
6276 
6277   std::string GetTypeName() const final;
6278 
6279   // nested types ----------------------------------------------------
6280 
6281   // accessors -------------------------------------------------------
6282 
6283   enum : int {
6284     kStepSequenceFieldNumber = 1,
6285   };
6286   // repeated .tensorflow.StepSequence step_sequence = 1;
6287   int step_sequence_size() const;
6288   private:
6289   int _internal_step_sequence_size() const;
6290   public:
6291   void clear_step_sequence();
6292   ::tensorflow::StepSequence* mutable_step_sequence(int index);
6293   ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StepSequence >*
6294       mutable_step_sequence();
6295   private:
6296   const ::tensorflow::StepSequence& _internal_step_sequence(int index) const;
6297   ::tensorflow::StepSequence* _internal_add_step_sequence();
6298   public:
6299   const ::tensorflow::StepSequence& step_sequence(int index) const;
6300   ::tensorflow::StepSequence* add_step_sequence();
6301   const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StepSequence >&
6302       step_sequence() const;
6303 
6304   // @@protoc_insertion_point(class_scope:tensorflow.GetStepSequenceResponse)
6305  private:
6306   class _Internal;
6307 
6308   template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
6309   typedef void InternalArenaConstructable_;
6310   typedef void DestructorSkippable_;
6311   struct Impl_ {
6312     ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StepSequence > step_sequence_;
6313     mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
6314   };
6315   union { Impl_ _impl_; };
6316   friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fworker_2eproto;
6317 };
6318 // ===================================================================
6319 
6320 
6321 // ===================================================================
6322 
6323 #ifdef __GNUC__
6324   #pragma GCC diagnostic push
6325   #pragma GCC diagnostic ignored "-Wstrict-aliasing"
6326 #endif  // __GNUC__
6327 // GetStatusRequest
6328 
6329 // -------------------------------------------------------------------
6330 
6331 // GetStatusResponse
6332 
6333 // repeated .tensorflow.DeviceAttributes device_attributes = 1;
_internal_device_attributes_size()6334 inline int GetStatusResponse::_internal_device_attributes_size() const {
6335   return _impl_.device_attributes_.size();
6336 }
device_attributes_size()6337 inline int GetStatusResponse::device_attributes_size() const {
6338   return _internal_device_attributes_size();
6339 }
mutable_device_attributes(int index)6340 inline ::tensorflow::DeviceAttributes* GetStatusResponse::mutable_device_attributes(int index) {
6341   // @@protoc_insertion_point(field_mutable:tensorflow.GetStatusResponse.device_attributes)
6342   return _impl_.device_attributes_.Mutable(index);
6343 }
6344 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
mutable_device_attributes()6345 GetStatusResponse::mutable_device_attributes() {
6346   // @@protoc_insertion_point(field_mutable_list:tensorflow.GetStatusResponse.device_attributes)
6347   return &_impl_.device_attributes_;
6348 }
_internal_device_attributes(int index)6349 inline const ::tensorflow::DeviceAttributes& GetStatusResponse::_internal_device_attributes(int index) const {
6350   return _impl_.device_attributes_.Get(index);
6351 }
device_attributes(int index)6352 inline const ::tensorflow::DeviceAttributes& GetStatusResponse::device_attributes(int index) const {
6353   // @@protoc_insertion_point(field_get:tensorflow.GetStatusResponse.device_attributes)
6354   return _internal_device_attributes(index);
6355 }
_internal_add_device_attributes()6356 inline ::tensorflow::DeviceAttributes* GetStatusResponse::_internal_add_device_attributes() {
6357   return _impl_.device_attributes_.Add();
6358 }
add_device_attributes()6359 inline ::tensorflow::DeviceAttributes* GetStatusResponse::add_device_attributes() {
6360   ::tensorflow::DeviceAttributes* _add = _internal_add_device_attributes();
6361   // @@protoc_insertion_point(field_add:tensorflow.GetStatusResponse.device_attributes)
6362   return _add;
6363 }
6364 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
device_attributes()6365 GetStatusResponse::device_attributes() const {
6366   // @@protoc_insertion_point(field_list:tensorflow.GetStatusResponse.device_attributes)
6367   return _impl_.device_attributes_;
6368 }
6369 
6370 // -------------------------------------------------------------------
6371 
6372 // CreateWorkerSessionRequest
6373 
6374 // string session_handle = 1;
clear_session_handle()6375 inline void CreateWorkerSessionRequest::clear_session_handle() {
6376   _impl_.session_handle_.ClearToEmpty();
6377 }
session_handle()6378 inline const std::string& CreateWorkerSessionRequest::session_handle() const {
6379   // @@protoc_insertion_point(field_get:tensorflow.CreateWorkerSessionRequest.session_handle)
6380   return _internal_session_handle();
6381 }
6382 template <typename ArgT0, typename... ArgT>
6383 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)6384 void CreateWorkerSessionRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
6385 
6386  _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6387   // @@protoc_insertion_point(field_set:tensorflow.CreateWorkerSessionRequest.session_handle)
6388 }
mutable_session_handle()6389 inline std::string* CreateWorkerSessionRequest::mutable_session_handle() {
6390   std::string* _s = _internal_mutable_session_handle();
6391   // @@protoc_insertion_point(field_mutable:tensorflow.CreateWorkerSessionRequest.session_handle)
6392   return _s;
6393 }
_internal_session_handle()6394 inline const std::string& CreateWorkerSessionRequest::_internal_session_handle() const {
6395   return _impl_.session_handle_.Get();
6396 }
_internal_set_session_handle(const std::string & value)6397 inline void CreateWorkerSessionRequest::_internal_set_session_handle(const std::string& value) {
6398 
6399   _impl_.session_handle_.Set(value, GetArenaForAllocation());
6400 }
_internal_mutable_session_handle()6401 inline std::string* CreateWorkerSessionRequest::_internal_mutable_session_handle() {
6402 
6403   return _impl_.session_handle_.Mutable(GetArenaForAllocation());
6404 }
release_session_handle()6405 inline std::string* CreateWorkerSessionRequest::release_session_handle() {
6406   // @@protoc_insertion_point(field_release:tensorflow.CreateWorkerSessionRequest.session_handle)
6407   return _impl_.session_handle_.Release();
6408 }
set_allocated_session_handle(std::string * session_handle)6409 inline void CreateWorkerSessionRequest::set_allocated_session_handle(std::string* session_handle) {
6410   _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
6411 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6412   if (_impl_.session_handle_.IsDefault()) {
6413     _impl_.session_handle_.Set("", GetArenaForAllocation());
6414   }
6415 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6416   // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateWorkerSessionRequest.session_handle)
6417 }
6418 
6419 // .tensorflow.ServerDef server_def = 2;
_internal_has_server_def()6420 inline bool CreateWorkerSessionRequest::_internal_has_server_def() const {
6421   return this != internal_default_instance() && _impl_.server_def_ != nullptr;
6422 }
has_server_def()6423 inline bool CreateWorkerSessionRequest::has_server_def() const {
6424   return _internal_has_server_def();
6425 }
_internal_server_def()6426 inline const ::tensorflow::ServerDef& CreateWorkerSessionRequest::_internal_server_def() const {
6427   const ::tensorflow::ServerDef* p = _impl_.server_def_;
6428   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::ServerDef&>(
6429       ::tensorflow::_ServerDef_default_instance_);
6430 }
server_def()6431 inline const ::tensorflow::ServerDef& CreateWorkerSessionRequest::server_def() const {
6432   // @@protoc_insertion_point(field_get:tensorflow.CreateWorkerSessionRequest.server_def)
6433   return _internal_server_def();
6434 }
unsafe_arena_set_allocated_server_def(::tensorflow::ServerDef * server_def)6435 inline void CreateWorkerSessionRequest::unsafe_arena_set_allocated_server_def(
6436     ::tensorflow::ServerDef* server_def) {
6437   if (GetArenaForAllocation() == nullptr) {
6438     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_def_);
6439   }
6440   _impl_.server_def_ = server_def;
6441   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CreateWorkerSessionRequest.server_def)
6442 }
release_server_def()6443 inline ::tensorflow::ServerDef* CreateWorkerSessionRequest::release_server_def() {
6444 
6445   ::tensorflow::ServerDef* temp = _impl_.server_def_;
6446   _impl_.server_def_ = nullptr;
6447 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6448   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6449   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6450   if (GetArenaForAllocation() == nullptr) { delete old; }
6451 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6452   if (GetArenaForAllocation() != nullptr) {
6453     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6454   }
6455 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6456   return temp;
6457 }
unsafe_arena_release_server_def()6458 inline ::tensorflow::ServerDef* CreateWorkerSessionRequest::unsafe_arena_release_server_def() {
6459   // @@protoc_insertion_point(field_release:tensorflow.CreateWorkerSessionRequest.server_def)
6460 
6461   ::tensorflow::ServerDef* temp = _impl_.server_def_;
6462   _impl_.server_def_ = nullptr;
6463   return temp;
6464 }
_internal_mutable_server_def()6465 inline ::tensorflow::ServerDef* CreateWorkerSessionRequest::_internal_mutable_server_def() {
6466 
6467   if (_impl_.server_def_ == nullptr) {
6468     auto* p = CreateMaybeMessage<::tensorflow::ServerDef>(GetArenaForAllocation());
6469     _impl_.server_def_ = p;
6470   }
6471   return _impl_.server_def_;
6472 }
mutable_server_def()6473 inline ::tensorflow::ServerDef* CreateWorkerSessionRequest::mutable_server_def() {
6474   ::tensorflow::ServerDef* _msg = _internal_mutable_server_def();
6475   // @@protoc_insertion_point(field_mutable:tensorflow.CreateWorkerSessionRequest.server_def)
6476   return _msg;
6477 }
set_allocated_server_def(::tensorflow::ServerDef * server_def)6478 inline void CreateWorkerSessionRequest::set_allocated_server_def(::tensorflow::ServerDef* server_def) {
6479   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6480   if (message_arena == nullptr) {
6481     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_def_);
6482   }
6483   if (server_def) {
6484     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6485         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
6486                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(server_def));
6487     if (message_arena != submessage_arena) {
6488       server_def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6489           message_arena, server_def, submessage_arena);
6490     }
6491 
6492   } else {
6493 
6494   }
6495   _impl_.server_def_ = server_def;
6496   // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateWorkerSessionRequest.server_def)
6497 }
6498 
6499 // bool isolate_session_state = 3;
clear_isolate_session_state()6500 inline void CreateWorkerSessionRequest::clear_isolate_session_state() {
6501   _impl_.isolate_session_state_ = false;
6502 }
_internal_isolate_session_state()6503 inline bool CreateWorkerSessionRequest::_internal_isolate_session_state() const {
6504   return _impl_.isolate_session_state_;
6505 }
isolate_session_state()6506 inline bool CreateWorkerSessionRequest::isolate_session_state() const {
6507   // @@protoc_insertion_point(field_get:tensorflow.CreateWorkerSessionRequest.isolate_session_state)
6508   return _internal_isolate_session_state();
6509 }
_internal_set_isolate_session_state(bool value)6510 inline void CreateWorkerSessionRequest::_internal_set_isolate_session_state(bool value) {
6511 
6512   _impl_.isolate_session_state_ = value;
6513 }
set_isolate_session_state(bool value)6514 inline void CreateWorkerSessionRequest::set_isolate_session_state(bool value) {
6515   _internal_set_isolate_session_state(value);
6516   // @@protoc_insertion_point(field_set:tensorflow.CreateWorkerSessionRequest.isolate_session_state)
6517 }
6518 
6519 // repeated .tensorflow.DeviceAttributes cluster_device_attributes = 4;
_internal_cluster_device_attributes_size()6520 inline int CreateWorkerSessionRequest::_internal_cluster_device_attributes_size() const {
6521   return _impl_.cluster_device_attributes_.size();
6522 }
cluster_device_attributes_size()6523 inline int CreateWorkerSessionRequest::cluster_device_attributes_size() const {
6524   return _internal_cluster_device_attributes_size();
6525 }
mutable_cluster_device_attributes(int index)6526 inline ::tensorflow::DeviceAttributes* CreateWorkerSessionRequest::mutable_cluster_device_attributes(int index) {
6527   // @@protoc_insertion_point(field_mutable:tensorflow.CreateWorkerSessionRequest.cluster_device_attributes)
6528   return _impl_.cluster_device_attributes_.Mutable(index);
6529 }
6530 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
mutable_cluster_device_attributes()6531 CreateWorkerSessionRequest::mutable_cluster_device_attributes() {
6532   // @@protoc_insertion_point(field_mutable_list:tensorflow.CreateWorkerSessionRequest.cluster_device_attributes)
6533   return &_impl_.cluster_device_attributes_;
6534 }
_internal_cluster_device_attributes(int index)6535 inline const ::tensorflow::DeviceAttributes& CreateWorkerSessionRequest::_internal_cluster_device_attributes(int index) const {
6536   return _impl_.cluster_device_attributes_.Get(index);
6537 }
cluster_device_attributes(int index)6538 inline const ::tensorflow::DeviceAttributes& CreateWorkerSessionRequest::cluster_device_attributes(int index) const {
6539   // @@protoc_insertion_point(field_get:tensorflow.CreateWorkerSessionRequest.cluster_device_attributes)
6540   return _internal_cluster_device_attributes(index);
6541 }
_internal_add_cluster_device_attributes()6542 inline ::tensorflow::DeviceAttributes* CreateWorkerSessionRequest::_internal_add_cluster_device_attributes() {
6543   return _impl_.cluster_device_attributes_.Add();
6544 }
add_cluster_device_attributes()6545 inline ::tensorflow::DeviceAttributes* CreateWorkerSessionRequest::add_cluster_device_attributes() {
6546   ::tensorflow::DeviceAttributes* _add = _internal_add_cluster_device_attributes();
6547   // @@protoc_insertion_point(field_add:tensorflow.CreateWorkerSessionRequest.cluster_device_attributes)
6548   return _add;
6549 }
6550 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
cluster_device_attributes()6551 CreateWorkerSessionRequest::cluster_device_attributes() const {
6552   // @@protoc_insertion_point(field_list:tensorflow.CreateWorkerSessionRequest.cluster_device_attributes)
6553   return _impl_.cluster_device_attributes_;
6554 }
6555 
6556 // string master_task = 5;
clear_master_task()6557 inline void CreateWorkerSessionRequest::clear_master_task() {
6558   _impl_.master_task_.ClearToEmpty();
6559 }
master_task()6560 inline const std::string& CreateWorkerSessionRequest::master_task() const {
6561   // @@protoc_insertion_point(field_get:tensorflow.CreateWorkerSessionRequest.master_task)
6562   return _internal_master_task();
6563 }
6564 template <typename ArgT0, typename... ArgT>
6565 inline PROTOBUF_ALWAYS_INLINE
set_master_task(ArgT0 && arg0,ArgT...args)6566 void CreateWorkerSessionRequest::set_master_task(ArgT0&& arg0, ArgT... args) {
6567 
6568  _impl_.master_task_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6569   // @@protoc_insertion_point(field_set:tensorflow.CreateWorkerSessionRequest.master_task)
6570 }
mutable_master_task()6571 inline std::string* CreateWorkerSessionRequest::mutable_master_task() {
6572   std::string* _s = _internal_mutable_master_task();
6573   // @@protoc_insertion_point(field_mutable:tensorflow.CreateWorkerSessionRequest.master_task)
6574   return _s;
6575 }
_internal_master_task()6576 inline const std::string& CreateWorkerSessionRequest::_internal_master_task() const {
6577   return _impl_.master_task_.Get();
6578 }
_internal_set_master_task(const std::string & value)6579 inline void CreateWorkerSessionRequest::_internal_set_master_task(const std::string& value) {
6580 
6581   _impl_.master_task_.Set(value, GetArenaForAllocation());
6582 }
_internal_mutable_master_task()6583 inline std::string* CreateWorkerSessionRequest::_internal_mutable_master_task() {
6584 
6585   return _impl_.master_task_.Mutable(GetArenaForAllocation());
6586 }
release_master_task()6587 inline std::string* CreateWorkerSessionRequest::release_master_task() {
6588   // @@protoc_insertion_point(field_release:tensorflow.CreateWorkerSessionRequest.master_task)
6589   return _impl_.master_task_.Release();
6590 }
set_allocated_master_task(std::string * master_task)6591 inline void CreateWorkerSessionRequest::set_allocated_master_task(std::string* master_task) {
6592   _impl_.master_task_.SetAllocated(master_task, GetArenaForAllocation());
6593 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6594   if (_impl_.master_task_.IsDefault()) {
6595     _impl_.master_task_.Set("", GetArenaForAllocation());
6596   }
6597 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6598   // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateWorkerSessionRequest.master_task)
6599 }
6600 
6601 // int64 master_incarnation = 6;
clear_master_incarnation()6602 inline void CreateWorkerSessionRequest::clear_master_incarnation() {
6603   _impl_.master_incarnation_ = ::int64_t{0};
6604 }
_internal_master_incarnation()6605 inline ::int64_t CreateWorkerSessionRequest::_internal_master_incarnation() const {
6606   return _impl_.master_incarnation_;
6607 }
master_incarnation()6608 inline ::int64_t CreateWorkerSessionRequest::master_incarnation() const {
6609   // @@protoc_insertion_point(field_get:tensorflow.CreateWorkerSessionRequest.master_incarnation)
6610   return _internal_master_incarnation();
6611 }
_internal_set_master_incarnation(::int64_t value)6612 inline void CreateWorkerSessionRequest::_internal_set_master_incarnation(::int64_t value) {
6613 
6614   _impl_.master_incarnation_ = value;
6615 }
set_master_incarnation(::int64_t value)6616 inline void CreateWorkerSessionRequest::set_master_incarnation(::int64_t value) {
6617   _internal_set_master_incarnation(value);
6618   // @@protoc_insertion_point(field_set:tensorflow.CreateWorkerSessionRequest.master_incarnation)
6619 }
6620 
6621 // -------------------------------------------------------------------
6622 
6623 // CreateWorkerSessionResponse
6624 
6625 // -------------------------------------------------------------------
6626 
6627 // DeleteWorkerSessionRequest
6628 
6629 // string session_handle = 1;
clear_session_handle()6630 inline void DeleteWorkerSessionRequest::clear_session_handle() {
6631   _impl_.session_handle_.ClearToEmpty();
6632 }
session_handle()6633 inline const std::string& DeleteWorkerSessionRequest::session_handle() const {
6634   // @@protoc_insertion_point(field_get:tensorflow.DeleteWorkerSessionRequest.session_handle)
6635   return _internal_session_handle();
6636 }
6637 template <typename ArgT0, typename... ArgT>
6638 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)6639 void DeleteWorkerSessionRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
6640 
6641  _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6642   // @@protoc_insertion_point(field_set:tensorflow.DeleteWorkerSessionRequest.session_handle)
6643 }
mutable_session_handle()6644 inline std::string* DeleteWorkerSessionRequest::mutable_session_handle() {
6645   std::string* _s = _internal_mutable_session_handle();
6646   // @@protoc_insertion_point(field_mutable:tensorflow.DeleteWorkerSessionRequest.session_handle)
6647   return _s;
6648 }
_internal_session_handle()6649 inline const std::string& DeleteWorkerSessionRequest::_internal_session_handle() const {
6650   return _impl_.session_handle_.Get();
6651 }
_internal_set_session_handle(const std::string & value)6652 inline void DeleteWorkerSessionRequest::_internal_set_session_handle(const std::string& value) {
6653 
6654   _impl_.session_handle_.Set(value, GetArenaForAllocation());
6655 }
_internal_mutable_session_handle()6656 inline std::string* DeleteWorkerSessionRequest::_internal_mutable_session_handle() {
6657 
6658   return _impl_.session_handle_.Mutable(GetArenaForAllocation());
6659 }
release_session_handle()6660 inline std::string* DeleteWorkerSessionRequest::release_session_handle() {
6661   // @@protoc_insertion_point(field_release:tensorflow.DeleteWorkerSessionRequest.session_handle)
6662   return _impl_.session_handle_.Release();
6663 }
set_allocated_session_handle(std::string * session_handle)6664 inline void DeleteWorkerSessionRequest::set_allocated_session_handle(std::string* session_handle) {
6665   _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
6666 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6667   if (_impl_.session_handle_.IsDefault()) {
6668     _impl_.session_handle_.Set("", GetArenaForAllocation());
6669   }
6670 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6671   // @@protoc_insertion_point(field_set_allocated:tensorflow.DeleteWorkerSessionRequest.session_handle)
6672 }
6673 
6674 // -------------------------------------------------------------------
6675 
6676 // DeleteWorkerSessionResponse
6677 
6678 // -------------------------------------------------------------------
6679 
6680 // RegisterGraphRequest
6681 
6682 // string session_handle = 1;
clear_session_handle()6683 inline void RegisterGraphRequest::clear_session_handle() {
6684   _impl_.session_handle_.ClearToEmpty();
6685 }
session_handle()6686 inline const std::string& RegisterGraphRequest::session_handle() const {
6687   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.session_handle)
6688   return _internal_session_handle();
6689 }
6690 template <typename ArgT0, typename... ArgT>
6691 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)6692 void RegisterGraphRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
6693 
6694  _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
6695   // @@protoc_insertion_point(field_set:tensorflow.RegisterGraphRequest.session_handle)
6696 }
mutable_session_handle()6697 inline std::string* RegisterGraphRequest::mutable_session_handle() {
6698   std::string* _s = _internal_mutable_session_handle();
6699   // @@protoc_insertion_point(field_mutable:tensorflow.RegisterGraphRequest.session_handle)
6700   return _s;
6701 }
_internal_session_handle()6702 inline const std::string& RegisterGraphRequest::_internal_session_handle() const {
6703   return _impl_.session_handle_.Get();
6704 }
_internal_set_session_handle(const std::string & value)6705 inline void RegisterGraphRequest::_internal_set_session_handle(const std::string& value) {
6706 
6707   _impl_.session_handle_.Set(value, GetArenaForAllocation());
6708 }
_internal_mutable_session_handle()6709 inline std::string* RegisterGraphRequest::_internal_mutable_session_handle() {
6710 
6711   return _impl_.session_handle_.Mutable(GetArenaForAllocation());
6712 }
release_session_handle()6713 inline std::string* RegisterGraphRequest::release_session_handle() {
6714   // @@protoc_insertion_point(field_release:tensorflow.RegisterGraphRequest.session_handle)
6715   return _impl_.session_handle_.Release();
6716 }
set_allocated_session_handle(std::string * session_handle)6717 inline void RegisterGraphRequest::set_allocated_session_handle(std::string* session_handle) {
6718   _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
6719 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
6720   if (_impl_.session_handle_.IsDefault()) {
6721     _impl_.session_handle_.Set("", GetArenaForAllocation());
6722   }
6723 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
6724   // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterGraphRequest.session_handle)
6725 }
6726 
6727 // bool create_worker_session_called = 6;
clear_create_worker_session_called()6728 inline void RegisterGraphRequest::clear_create_worker_session_called() {
6729   _impl_.create_worker_session_called_ = false;
6730 }
_internal_create_worker_session_called()6731 inline bool RegisterGraphRequest::_internal_create_worker_session_called() const {
6732   return _impl_.create_worker_session_called_;
6733 }
create_worker_session_called()6734 inline bool RegisterGraphRequest::create_worker_session_called() const {
6735   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.create_worker_session_called)
6736   return _internal_create_worker_session_called();
6737 }
_internal_set_create_worker_session_called(bool value)6738 inline void RegisterGraphRequest::_internal_set_create_worker_session_called(bool value) {
6739 
6740   _impl_.create_worker_session_called_ = value;
6741 }
set_create_worker_session_called(bool value)6742 inline void RegisterGraphRequest::set_create_worker_session_called(bool value) {
6743   _internal_set_create_worker_session_called(value);
6744   // @@protoc_insertion_point(field_set:tensorflow.RegisterGraphRequest.create_worker_session_called)
6745 }
6746 
6747 // .tensorflow.GraphDef graph_def = 2;
_internal_has_graph_def()6748 inline bool RegisterGraphRequest::_internal_has_graph_def() const {
6749   return this != internal_default_instance() && _impl_.graph_def_ != nullptr;
6750 }
has_graph_def()6751 inline bool RegisterGraphRequest::has_graph_def() const {
6752   return _internal_has_graph_def();
6753 }
_internal_graph_def()6754 inline const ::tensorflow::GraphDef& RegisterGraphRequest::_internal_graph_def() const {
6755   const ::tensorflow::GraphDef* p = _impl_.graph_def_;
6756   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::GraphDef&>(
6757       ::tensorflow::_GraphDef_default_instance_);
6758 }
graph_def()6759 inline const ::tensorflow::GraphDef& RegisterGraphRequest::graph_def() const {
6760   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.graph_def)
6761   return _internal_graph_def();
6762 }
unsafe_arena_set_allocated_graph_def(::tensorflow::GraphDef * graph_def)6763 inline void RegisterGraphRequest::unsafe_arena_set_allocated_graph_def(
6764     ::tensorflow::GraphDef* graph_def) {
6765   if (GetArenaForAllocation() == nullptr) {
6766     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_def_);
6767   }
6768   _impl_.graph_def_ = graph_def;
6769   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RegisterGraphRequest.graph_def)
6770 }
release_graph_def()6771 inline ::tensorflow::GraphDef* RegisterGraphRequest::release_graph_def() {
6772 
6773   ::tensorflow::GraphDef* temp = _impl_.graph_def_;
6774   _impl_.graph_def_ = nullptr;
6775 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6776   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6777   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6778   if (GetArenaForAllocation() == nullptr) { delete old; }
6779 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6780   if (GetArenaForAllocation() != nullptr) {
6781     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6782   }
6783 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6784   return temp;
6785 }
unsafe_arena_release_graph_def()6786 inline ::tensorflow::GraphDef* RegisterGraphRequest::unsafe_arena_release_graph_def() {
6787   // @@protoc_insertion_point(field_release:tensorflow.RegisterGraphRequest.graph_def)
6788 
6789   ::tensorflow::GraphDef* temp = _impl_.graph_def_;
6790   _impl_.graph_def_ = nullptr;
6791   return temp;
6792 }
_internal_mutable_graph_def()6793 inline ::tensorflow::GraphDef* RegisterGraphRequest::_internal_mutable_graph_def() {
6794 
6795   if (_impl_.graph_def_ == nullptr) {
6796     auto* p = CreateMaybeMessage<::tensorflow::GraphDef>(GetArenaForAllocation());
6797     _impl_.graph_def_ = p;
6798   }
6799   return _impl_.graph_def_;
6800 }
mutable_graph_def()6801 inline ::tensorflow::GraphDef* RegisterGraphRequest::mutable_graph_def() {
6802   ::tensorflow::GraphDef* _msg = _internal_mutable_graph_def();
6803   // @@protoc_insertion_point(field_mutable:tensorflow.RegisterGraphRequest.graph_def)
6804   return _msg;
6805 }
set_allocated_graph_def(::tensorflow::GraphDef * graph_def)6806 inline void RegisterGraphRequest::set_allocated_graph_def(::tensorflow::GraphDef* graph_def) {
6807   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6808   if (message_arena == nullptr) {
6809     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_def_);
6810   }
6811   if (graph_def) {
6812     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6813         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
6814                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_def));
6815     if (message_arena != submessage_arena) {
6816       graph_def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6817           message_arena, graph_def, submessage_arena);
6818     }
6819 
6820   } else {
6821 
6822   }
6823   _impl_.graph_def_ = graph_def;
6824   // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterGraphRequest.graph_def)
6825 }
6826 
6827 // bool has_control_flow = 3 [deprecated = true];
clear_has_control_flow()6828 inline void RegisterGraphRequest::clear_has_control_flow() {
6829   _impl_.has_control_flow_ = false;
6830 }
_internal_has_control_flow()6831 inline bool RegisterGraphRequest::_internal_has_control_flow() const {
6832   return _impl_.has_control_flow_;
6833 }
has_control_flow()6834 inline bool RegisterGraphRequest::has_control_flow() const {
6835   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.has_control_flow)
6836   return _internal_has_control_flow();
6837 }
_internal_set_has_control_flow(bool value)6838 inline void RegisterGraphRequest::_internal_set_has_control_flow(bool value) {
6839 
6840   _impl_.has_control_flow_ = value;
6841 }
set_has_control_flow(bool value)6842 inline void RegisterGraphRequest::set_has_control_flow(bool value) {
6843   _internal_set_has_control_flow(value);
6844   // @@protoc_insertion_point(field_set:tensorflow.RegisterGraphRequest.has_control_flow)
6845 }
6846 
6847 // .tensorflow.GraphOptions graph_options = 4;
_internal_has_graph_options()6848 inline bool RegisterGraphRequest::_internal_has_graph_options() const {
6849   return this != internal_default_instance() && _impl_.graph_options_ != nullptr;
6850 }
has_graph_options()6851 inline bool RegisterGraphRequest::has_graph_options() const {
6852   return _internal_has_graph_options();
6853 }
_internal_graph_options()6854 inline const ::tensorflow::GraphOptions& RegisterGraphRequest::_internal_graph_options() const {
6855   const ::tensorflow::GraphOptions* p = _impl_.graph_options_;
6856   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::GraphOptions&>(
6857       ::tensorflow::_GraphOptions_default_instance_);
6858 }
graph_options()6859 inline const ::tensorflow::GraphOptions& RegisterGraphRequest::graph_options() const {
6860   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.graph_options)
6861   return _internal_graph_options();
6862 }
unsafe_arena_set_allocated_graph_options(::tensorflow::GraphOptions * graph_options)6863 inline void RegisterGraphRequest::unsafe_arena_set_allocated_graph_options(
6864     ::tensorflow::GraphOptions* graph_options) {
6865   if (GetArenaForAllocation() == nullptr) {
6866     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_options_);
6867   }
6868   _impl_.graph_options_ = graph_options;
6869   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RegisterGraphRequest.graph_options)
6870 }
release_graph_options()6871 inline ::tensorflow::GraphOptions* RegisterGraphRequest::release_graph_options() {
6872 
6873   ::tensorflow::GraphOptions* temp = _impl_.graph_options_;
6874   _impl_.graph_options_ = nullptr;
6875 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6876   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6877   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6878   if (GetArenaForAllocation() == nullptr) { delete old; }
6879 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6880   if (GetArenaForAllocation() != nullptr) {
6881     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6882   }
6883 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6884   return temp;
6885 }
unsafe_arena_release_graph_options()6886 inline ::tensorflow::GraphOptions* RegisterGraphRequest::unsafe_arena_release_graph_options() {
6887   // @@protoc_insertion_point(field_release:tensorflow.RegisterGraphRequest.graph_options)
6888 
6889   ::tensorflow::GraphOptions* temp = _impl_.graph_options_;
6890   _impl_.graph_options_ = nullptr;
6891   return temp;
6892 }
_internal_mutable_graph_options()6893 inline ::tensorflow::GraphOptions* RegisterGraphRequest::_internal_mutable_graph_options() {
6894 
6895   if (_impl_.graph_options_ == nullptr) {
6896     auto* p = CreateMaybeMessage<::tensorflow::GraphOptions>(GetArenaForAllocation());
6897     _impl_.graph_options_ = p;
6898   }
6899   return _impl_.graph_options_;
6900 }
mutable_graph_options()6901 inline ::tensorflow::GraphOptions* RegisterGraphRequest::mutable_graph_options() {
6902   ::tensorflow::GraphOptions* _msg = _internal_mutable_graph_options();
6903   // @@protoc_insertion_point(field_mutable:tensorflow.RegisterGraphRequest.graph_options)
6904   return _msg;
6905 }
set_allocated_graph_options(::tensorflow::GraphOptions * graph_options)6906 inline void RegisterGraphRequest::set_allocated_graph_options(::tensorflow::GraphOptions* graph_options) {
6907   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6908   if (message_arena == nullptr) {
6909     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_options_);
6910   }
6911   if (graph_options) {
6912     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6913         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
6914                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_options));
6915     if (message_arena != submessage_arena) {
6916       graph_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6917           message_arena, graph_options, submessage_arena);
6918     }
6919 
6920   } else {
6921 
6922   }
6923   _impl_.graph_options_ = graph_options;
6924   // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterGraphRequest.graph_options)
6925 }
6926 
6927 // .tensorflow.DebugOptions debug_options = 5;
_internal_has_debug_options()6928 inline bool RegisterGraphRequest::_internal_has_debug_options() const {
6929   return this != internal_default_instance() && _impl_.debug_options_ != nullptr;
6930 }
has_debug_options()6931 inline bool RegisterGraphRequest::has_debug_options() const {
6932   return _internal_has_debug_options();
6933 }
_internal_debug_options()6934 inline const ::tensorflow::DebugOptions& RegisterGraphRequest::_internal_debug_options() const {
6935   const ::tensorflow::DebugOptions* p = _impl_.debug_options_;
6936   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DebugOptions&>(
6937       ::tensorflow::_DebugOptions_default_instance_);
6938 }
debug_options()6939 inline const ::tensorflow::DebugOptions& RegisterGraphRequest::debug_options() const {
6940   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.debug_options)
6941   return _internal_debug_options();
6942 }
unsafe_arena_set_allocated_debug_options(::tensorflow::DebugOptions * debug_options)6943 inline void RegisterGraphRequest::unsafe_arena_set_allocated_debug_options(
6944     ::tensorflow::DebugOptions* debug_options) {
6945   if (GetArenaForAllocation() == nullptr) {
6946     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debug_options_);
6947   }
6948   _impl_.debug_options_ = debug_options;
6949   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RegisterGraphRequest.debug_options)
6950 }
release_debug_options()6951 inline ::tensorflow::DebugOptions* RegisterGraphRequest::release_debug_options() {
6952 
6953   ::tensorflow::DebugOptions* temp = _impl_.debug_options_;
6954   _impl_.debug_options_ = nullptr;
6955 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
6956   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
6957   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6958   if (GetArenaForAllocation() == nullptr) { delete old; }
6959 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
6960   if (GetArenaForAllocation() != nullptr) {
6961     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
6962   }
6963 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
6964   return temp;
6965 }
unsafe_arena_release_debug_options()6966 inline ::tensorflow::DebugOptions* RegisterGraphRequest::unsafe_arena_release_debug_options() {
6967   // @@protoc_insertion_point(field_release:tensorflow.RegisterGraphRequest.debug_options)
6968 
6969   ::tensorflow::DebugOptions* temp = _impl_.debug_options_;
6970   _impl_.debug_options_ = nullptr;
6971   return temp;
6972 }
_internal_mutable_debug_options()6973 inline ::tensorflow::DebugOptions* RegisterGraphRequest::_internal_mutable_debug_options() {
6974 
6975   if (_impl_.debug_options_ == nullptr) {
6976     auto* p = CreateMaybeMessage<::tensorflow::DebugOptions>(GetArenaForAllocation());
6977     _impl_.debug_options_ = p;
6978   }
6979   return _impl_.debug_options_;
6980 }
mutable_debug_options()6981 inline ::tensorflow::DebugOptions* RegisterGraphRequest::mutable_debug_options() {
6982   ::tensorflow::DebugOptions* _msg = _internal_mutable_debug_options();
6983   // @@protoc_insertion_point(field_mutable:tensorflow.RegisterGraphRequest.debug_options)
6984   return _msg;
6985 }
set_allocated_debug_options(::tensorflow::DebugOptions * debug_options)6986 inline void RegisterGraphRequest::set_allocated_debug_options(::tensorflow::DebugOptions* debug_options) {
6987   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
6988   if (message_arena == nullptr) {
6989     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debug_options_);
6990   }
6991   if (debug_options) {
6992     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
6993         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
6994                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(debug_options));
6995     if (message_arena != submessage_arena) {
6996       debug_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
6997           message_arena, debug_options, submessage_arena);
6998     }
6999 
7000   } else {
7001 
7002   }
7003   _impl_.debug_options_ = debug_options;
7004   // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterGraphRequest.debug_options)
7005 }
7006 
7007 // int64 collective_graph_key = 7;
clear_collective_graph_key()7008 inline void RegisterGraphRequest::clear_collective_graph_key() {
7009   _impl_.collective_graph_key_ = ::int64_t{0};
7010 }
_internal_collective_graph_key()7011 inline ::int64_t RegisterGraphRequest::_internal_collective_graph_key() const {
7012   return _impl_.collective_graph_key_;
7013 }
collective_graph_key()7014 inline ::int64_t RegisterGraphRequest::collective_graph_key() const {
7015   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.collective_graph_key)
7016   return _internal_collective_graph_key();
7017 }
_internal_set_collective_graph_key(::int64_t value)7018 inline void RegisterGraphRequest::_internal_set_collective_graph_key(::int64_t value) {
7019 
7020   _impl_.collective_graph_key_ = value;
7021 }
set_collective_graph_key(::int64_t value)7022 inline void RegisterGraphRequest::set_collective_graph_key(::int64_t value) {
7023   _internal_set_collective_graph_key(value);
7024   // @@protoc_insertion_point(field_set:tensorflow.RegisterGraphRequest.collective_graph_key)
7025 }
7026 
7027 // .tensorflow.ConfigProto config_proto = 8;
_internal_has_config_proto()7028 inline bool RegisterGraphRequest::_internal_has_config_proto() const {
7029   return this != internal_default_instance() && _impl_.config_proto_ != nullptr;
7030 }
has_config_proto()7031 inline bool RegisterGraphRequest::has_config_proto() const {
7032   return _internal_has_config_proto();
7033 }
_internal_config_proto()7034 inline const ::tensorflow::ConfigProto& RegisterGraphRequest::_internal_config_proto() const {
7035   const ::tensorflow::ConfigProto* p = _impl_.config_proto_;
7036   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::ConfigProto&>(
7037       ::tensorflow::_ConfigProto_default_instance_);
7038 }
config_proto()7039 inline const ::tensorflow::ConfigProto& RegisterGraphRequest::config_proto() const {
7040   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphRequest.config_proto)
7041   return _internal_config_proto();
7042 }
unsafe_arena_set_allocated_config_proto(::tensorflow::ConfigProto * config_proto)7043 inline void RegisterGraphRequest::unsafe_arena_set_allocated_config_proto(
7044     ::tensorflow::ConfigProto* config_proto) {
7045   if (GetArenaForAllocation() == nullptr) {
7046     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.config_proto_);
7047   }
7048   _impl_.config_proto_ = config_proto;
7049   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RegisterGraphRequest.config_proto)
7050 }
release_config_proto()7051 inline ::tensorflow::ConfigProto* RegisterGraphRequest::release_config_proto() {
7052 
7053   ::tensorflow::ConfigProto* temp = _impl_.config_proto_;
7054   _impl_.config_proto_ = nullptr;
7055 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7056   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
7057   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7058   if (GetArenaForAllocation() == nullptr) { delete old; }
7059 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
7060   if (GetArenaForAllocation() != nullptr) {
7061     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7062   }
7063 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7064   return temp;
7065 }
unsafe_arena_release_config_proto()7066 inline ::tensorflow::ConfigProto* RegisterGraphRequest::unsafe_arena_release_config_proto() {
7067   // @@protoc_insertion_point(field_release:tensorflow.RegisterGraphRequest.config_proto)
7068 
7069   ::tensorflow::ConfigProto* temp = _impl_.config_proto_;
7070   _impl_.config_proto_ = nullptr;
7071   return temp;
7072 }
_internal_mutable_config_proto()7073 inline ::tensorflow::ConfigProto* RegisterGraphRequest::_internal_mutable_config_proto() {
7074 
7075   if (_impl_.config_proto_ == nullptr) {
7076     auto* p = CreateMaybeMessage<::tensorflow::ConfigProto>(GetArenaForAllocation());
7077     _impl_.config_proto_ = p;
7078   }
7079   return _impl_.config_proto_;
7080 }
mutable_config_proto()7081 inline ::tensorflow::ConfigProto* RegisterGraphRequest::mutable_config_proto() {
7082   ::tensorflow::ConfigProto* _msg = _internal_mutable_config_proto();
7083   // @@protoc_insertion_point(field_mutable:tensorflow.RegisterGraphRequest.config_proto)
7084   return _msg;
7085 }
set_allocated_config_proto(::tensorflow::ConfigProto * config_proto)7086 inline void RegisterGraphRequest::set_allocated_config_proto(::tensorflow::ConfigProto* config_proto) {
7087   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
7088   if (message_arena == nullptr) {
7089     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.config_proto_);
7090   }
7091   if (config_proto) {
7092     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
7093         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
7094                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(config_proto));
7095     if (message_arena != submessage_arena) {
7096       config_proto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7097           message_arena, config_proto, submessage_arena);
7098     }
7099 
7100   } else {
7101 
7102   }
7103   _impl_.config_proto_ = config_proto;
7104   // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterGraphRequest.config_proto)
7105 }
7106 
7107 // -------------------------------------------------------------------
7108 
7109 // RegisterGraphResponse
7110 
7111 // string graph_handle = 1;
clear_graph_handle()7112 inline void RegisterGraphResponse::clear_graph_handle() {
7113   _impl_.graph_handle_.ClearToEmpty();
7114 }
graph_handle()7115 inline const std::string& RegisterGraphResponse::graph_handle() const {
7116   // @@protoc_insertion_point(field_get:tensorflow.RegisterGraphResponse.graph_handle)
7117   return _internal_graph_handle();
7118 }
7119 template <typename ArgT0, typename... ArgT>
7120 inline PROTOBUF_ALWAYS_INLINE
set_graph_handle(ArgT0 && arg0,ArgT...args)7121 void RegisterGraphResponse::set_graph_handle(ArgT0&& arg0, ArgT... args) {
7122 
7123  _impl_.graph_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7124   // @@protoc_insertion_point(field_set:tensorflow.RegisterGraphResponse.graph_handle)
7125 }
mutable_graph_handle()7126 inline std::string* RegisterGraphResponse::mutable_graph_handle() {
7127   std::string* _s = _internal_mutable_graph_handle();
7128   // @@protoc_insertion_point(field_mutable:tensorflow.RegisterGraphResponse.graph_handle)
7129   return _s;
7130 }
_internal_graph_handle()7131 inline const std::string& RegisterGraphResponse::_internal_graph_handle() const {
7132   return _impl_.graph_handle_.Get();
7133 }
_internal_set_graph_handle(const std::string & value)7134 inline void RegisterGraphResponse::_internal_set_graph_handle(const std::string& value) {
7135 
7136   _impl_.graph_handle_.Set(value, GetArenaForAllocation());
7137 }
_internal_mutable_graph_handle()7138 inline std::string* RegisterGraphResponse::_internal_mutable_graph_handle() {
7139 
7140   return _impl_.graph_handle_.Mutable(GetArenaForAllocation());
7141 }
release_graph_handle()7142 inline std::string* RegisterGraphResponse::release_graph_handle() {
7143   // @@protoc_insertion_point(field_release:tensorflow.RegisterGraphResponse.graph_handle)
7144   return _impl_.graph_handle_.Release();
7145 }
set_allocated_graph_handle(std::string * graph_handle)7146 inline void RegisterGraphResponse::set_allocated_graph_handle(std::string* graph_handle) {
7147   _impl_.graph_handle_.SetAllocated(graph_handle, GetArenaForAllocation());
7148 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7149   if (_impl_.graph_handle_.IsDefault()) {
7150     _impl_.graph_handle_.Set("", GetArenaForAllocation());
7151   }
7152 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7153   // @@protoc_insertion_point(field_set_allocated:tensorflow.RegisterGraphResponse.graph_handle)
7154 }
7155 
7156 // -------------------------------------------------------------------
7157 
7158 // DeregisterGraphRequest
7159 
7160 // string session_handle = 2;
clear_session_handle()7161 inline void DeregisterGraphRequest::clear_session_handle() {
7162   _impl_.session_handle_.ClearToEmpty();
7163 }
session_handle()7164 inline const std::string& DeregisterGraphRequest::session_handle() const {
7165   // @@protoc_insertion_point(field_get:tensorflow.DeregisterGraphRequest.session_handle)
7166   return _internal_session_handle();
7167 }
7168 template <typename ArgT0, typename... ArgT>
7169 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)7170 void DeregisterGraphRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
7171 
7172  _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7173   // @@protoc_insertion_point(field_set:tensorflow.DeregisterGraphRequest.session_handle)
7174 }
mutable_session_handle()7175 inline std::string* DeregisterGraphRequest::mutable_session_handle() {
7176   std::string* _s = _internal_mutable_session_handle();
7177   // @@protoc_insertion_point(field_mutable:tensorflow.DeregisterGraphRequest.session_handle)
7178   return _s;
7179 }
_internal_session_handle()7180 inline const std::string& DeregisterGraphRequest::_internal_session_handle() const {
7181   return _impl_.session_handle_.Get();
7182 }
_internal_set_session_handle(const std::string & value)7183 inline void DeregisterGraphRequest::_internal_set_session_handle(const std::string& value) {
7184 
7185   _impl_.session_handle_.Set(value, GetArenaForAllocation());
7186 }
_internal_mutable_session_handle()7187 inline std::string* DeregisterGraphRequest::_internal_mutable_session_handle() {
7188 
7189   return _impl_.session_handle_.Mutable(GetArenaForAllocation());
7190 }
release_session_handle()7191 inline std::string* DeregisterGraphRequest::release_session_handle() {
7192   // @@protoc_insertion_point(field_release:tensorflow.DeregisterGraphRequest.session_handle)
7193   return _impl_.session_handle_.Release();
7194 }
set_allocated_session_handle(std::string * session_handle)7195 inline void DeregisterGraphRequest::set_allocated_session_handle(std::string* session_handle) {
7196   _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
7197 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7198   if (_impl_.session_handle_.IsDefault()) {
7199     _impl_.session_handle_.Set("", GetArenaForAllocation());
7200   }
7201 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7202   // @@protoc_insertion_point(field_set_allocated:tensorflow.DeregisterGraphRequest.session_handle)
7203 }
7204 
7205 // bool create_worker_session_called = 3;
clear_create_worker_session_called()7206 inline void DeregisterGraphRequest::clear_create_worker_session_called() {
7207   _impl_.create_worker_session_called_ = false;
7208 }
_internal_create_worker_session_called()7209 inline bool DeregisterGraphRequest::_internal_create_worker_session_called() const {
7210   return _impl_.create_worker_session_called_;
7211 }
create_worker_session_called()7212 inline bool DeregisterGraphRequest::create_worker_session_called() const {
7213   // @@protoc_insertion_point(field_get:tensorflow.DeregisterGraphRequest.create_worker_session_called)
7214   return _internal_create_worker_session_called();
7215 }
_internal_set_create_worker_session_called(bool value)7216 inline void DeregisterGraphRequest::_internal_set_create_worker_session_called(bool value) {
7217 
7218   _impl_.create_worker_session_called_ = value;
7219 }
set_create_worker_session_called(bool value)7220 inline void DeregisterGraphRequest::set_create_worker_session_called(bool value) {
7221   _internal_set_create_worker_session_called(value);
7222   // @@protoc_insertion_point(field_set:tensorflow.DeregisterGraphRequest.create_worker_session_called)
7223 }
7224 
7225 // string graph_handle = 1;
clear_graph_handle()7226 inline void DeregisterGraphRequest::clear_graph_handle() {
7227   _impl_.graph_handle_.ClearToEmpty();
7228 }
graph_handle()7229 inline const std::string& DeregisterGraphRequest::graph_handle() const {
7230   // @@protoc_insertion_point(field_get:tensorflow.DeregisterGraphRequest.graph_handle)
7231   return _internal_graph_handle();
7232 }
7233 template <typename ArgT0, typename... ArgT>
7234 inline PROTOBUF_ALWAYS_INLINE
set_graph_handle(ArgT0 && arg0,ArgT...args)7235 void DeregisterGraphRequest::set_graph_handle(ArgT0&& arg0, ArgT... args) {
7236 
7237  _impl_.graph_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7238   // @@protoc_insertion_point(field_set:tensorflow.DeregisterGraphRequest.graph_handle)
7239 }
mutable_graph_handle()7240 inline std::string* DeregisterGraphRequest::mutable_graph_handle() {
7241   std::string* _s = _internal_mutable_graph_handle();
7242   // @@protoc_insertion_point(field_mutable:tensorflow.DeregisterGraphRequest.graph_handle)
7243   return _s;
7244 }
_internal_graph_handle()7245 inline const std::string& DeregisterGraphRequest::_internal_graph_handle() const {
7246   return _impl_.graph_handle_.Get();
7247 }
_internal_set_graph_handle(const std::string & value)7248 inline void DeregisterGraphRequest::_internal_set_graph_handle(const std::string& value) {
7249 
7250   _impl_.graph_handle_.Set(value, GetArenaForAllocation());
7251 }
_internal_mutable_graph_handle()7252 inline std::string* DeregisterGraphRequest::_internal_mutable_graph_handle() {
7253 
7254   return _impl_.graph_handle_.Mutable(GetArenaForAllocation());
7255 }
release_graph_handle()7256 inline std::string* DeregisterGraphRequest::release_graph_handle() {
7257   // @@protoc_insertion_point(field_release:tensorflow.DeregisterGraphRequest.graph_handle)
7258   return _impl_.graph_handle_.Release();
7259 }
set_allocated_graph_handle(std::string * graph_handle)7260 inline void DeregisterGraphRequest::set_allocated_graph_handle(std::string* graph_handle) {
7261   _impl_.graph_handle_.SetAllocated(graph_handle, GetArenaForAllocation());
7262 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7263   if (_impl_.graph_handle_.IsDefault()) {
7264     _impl_.graph_handle_.Set("", GetArenaForAllocation());
7265   }
7266 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7267   // @@protoc_insertion_point(field_set_allocated:tensorflow.DeregisterGraphRequest.graph_handle)
7268 }
7269 
7270 // -------------------------------------------------------------------
7271 
7272 // DeregisterGraphResponse
7273 
7274 // -------------------------------------------------------------------
7275 
7276 // CleanupAllRequest
7277 
7278 // repeated string container = 1;
_internal_container_size()7279 inline int CleanupAllRequest::_internal_container_size() const {
7280   return _impl_.container_.size();
7281 }
container_size()7282 inline int CleanupAllRequest::container_size() const {
7283   return _internal_container_size();
7284 }
clear_container()7285 inline void CleanupAllRequest::clear_container() {
7286   _impl_.container_.Clear();
7287 }
add_container()7288 inline std::string* CleanupAllRequest::add_container() {
7289   std::string* _s = _internal_add_container();
7290   // @@protoc_insertion_point(field_add_mutable:tensorflow.CleanupAllRequest.container)
7291   return _s;
7292 }
_internal_container(int index)7293 inline const std::string& CleanupAllRequest::_internal_container(int index) const {
7294   return _impl_.container_.Get(index);
7295 }
container(int index)7296 inline const std::string& CleanupAllRequest::container(int index) const {
7297   // @@protoc_insertion_point(field_get:tensorflow.CleanupAllRequest.container)
7298   return _internal_container(index);
7299 }
mutable_container(int index)7300 inline std::string* CleanupAllRequest::mutable_container(int index) {
7301   // @@protoc_insertion_point(field_mutable:tensorflow.CleanupAllRequest.container)
7302   return _impl_.container_.Mutable(index);
7303 }
set_container(int index,const std::string & value)7304 inline void CleanupAllRequest::set_container(int index, const std::string& value) {
7305   _impl_.container_.Mutable(index)->assign(value);
7306   // @@protoc_insertion_point(field_set:tensorflow.CleanupAllRequest.container)
7307 }
set_container(int index,std::string && value)7308 inline void CleanupAllRequest::set_container(int index, std::string&& value) {
7309   _impl_.container_.Mutable(index)->assign(std::move(value));
7310   // @@protoc_insertion_point(field_set:tensorflow.CleanupAllRequest.container)
7311 }
set_container(int index,const char * value)7312 inline void CleanupAllRequest::set_container(int index, const char* value) {
7313   GOOGLE_DCHECK(value != nullptr);
7314   _impl_.container_.Mutable(index)->assign(value);
7315   // @@protoc_insertion_point(field_set_char:tensorflow.CleanupAllRequest.container)
7316 }
set_container(int index,const char * value,size_t size)7317 inline void CleanupAllRequest::set_container(int index, const char* value, size_t size) {
7318   _impl_.container_.Mutable(index)->assign(
7319     reinterpret_cast<const char*>(value), size);
7320   // @@protoc_insertion_point(field_set_pointer:tensorflow.CleanupAllRequest.container)
7321 }
_internal_add_container()7322 inline std::string* CleanupAllRequest::_internal_add_container() {
7323   return _impl_.container_.Add();
7324 }
add_container(const std::string & value)7325 inline void CleanupAllRequest::add_container(const std::string& value) {
7326   _impl_.container_.Add()->assign(value);
7327   // @@protoc_insertion_point(field_add:tensorflow.CleanupAllRequest.container)
7328 }
add_container(std::string && value)7329 inline void CleanupAllRequest::add_container(std::string&& value) {
7330   _impl_.container_.Add(std::move(value));
7331   // @@protoc_insertion_point(field_add:tensorflow.CleanupAllRequest.container)
7332 }
add_container(const char * value)7333 inline void CleanupAllRequest::add_container(const char* value) {
7334   GOOGLE_DCHECK(value != nullptr);
7335   _impl_.container_.Add()->assign(value);
7336   // @@protoc_insertion_point(field_add_char:tensorflow.CleanupAllRequest.container)
7337 }
add_container(const char * value,size_t size)7338 inline void CleanupAllRequest::add_container(const char* value, size_t size) {
7339   _impl_.container_.Add()->assign(reinterpret_cast<const char*>(value), size);
7340   // @@protoc_insertion_point(field_add_pointer:tensorflow.CleanupAllRequest.container)
7341 }
7342 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
container()7343 CleanupAllRequest::container() const {
7344   // @@protoc_insertion_point(field_list:tensorflow.CleanupAllRequest.container)
7345   return _impl_.container_;
7346 }
7347 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_container()7348 CleanupAllRequest::mutable_container() {
7349   // @@protoc_insertion_point(field_mutable_list:tensorflow.CleanupAllRequest.container)
7350   return &_impl_.container_;
7351 }
7352 
7353 // -------------------------------------------------------------------
7354 
7355 // CleanupAllResponse
7356 
7357 // -------------------------------------------------------------------
7358 
7359 // ExecutorOpts
7360 
7361 // bool record_costs = 1;
clear_record_costs()7362 inline void ExecutorOpts::clear_record_costs() {
7363   _impl_.record_costs_ = false;
7364 }
_internal_record_costs()7365 inline bool ExecutorOpts::_internal_record_costs() const {
7366   return _impl_.record_costs_;
7367 }
record_costs()7368 inline bool ExecutorOpts::record_costs() const {
7369   // @@protoc_insertion_point(field_get:tensorflow.ExecutorOpts.record_costs)
7370   return _internal_record_costs();
7371 }
_internal_set_record_costs(bool value)7372 inline void ExecutorOpts::_internal_set_record_costs(bool value) {
7373 
7374   _impl_.record_costs_ = value;
7375 }
set_record_costs(bool value)7376 inline void ExecutorOpts::set_record_costs(bool value) {
7377   _internal_set_record_costs(value);
7378   // @@protoc_insertion_point(field_set:tensorflow.ExecutorOpts.record_costs)
7379 }
7380 
7381 // bool record_timeline = 3;
clear_record_timeline()7382 inline void ExecutorOpts::clear_record_timeline() {
7383   _impl_.record_timeline_ = false;
7384 }
_internal_record_timeline()7385 inline bool ExecutorOpts::_internal_record_timeline() const {
7386   return _impl_.record_timeline_;
7387 }
record_timeline()7388 inline bool ExecutorOpts::record_timeline() const {
7389   // @@protoc_insertion_point(field_get:tensorflow.ExecutorOpts.record_timeline)
7390   return _internal_record_timeline();
7391 }
_internal_set_record_timeline(bool value)7392 inline void ExecutorOpts::_internal_set_record_timeline(bool value) {
7393 
7394   _impl_.record_timeline_ = value;
7395 }
set_record_timeline(bool value)7396 inline void ExecutorOpts::set_record_timeline(bool value) {
7397   _internal_set_record_timeline(value);
7398   // @@protoc_insertion_point(field_set:tensorflow.ExecutorOpts.record_timeline)
7399 }
7400 
7401 // bool record_partition_graphs = 4;
clear_record_partition_graphs()7402 inline void ExecutorOpts::clear_record_partition_graphs() {
7403   _impl_.record_partition_graphs_ = false;
7404 }
_internal_record_partition_graphs()7405 inline bool ExecutorOpts::_internal_record_partition_graphs() const {
7406   return _impl_.record_partition_graphs_;
7407 }
record_partition_graphs()7408 inline bool ExecutorOpts::record_partition_graphs() const {
7409   // @@protoc_insertion_point(field_get:tensorflow.ExecutorOpts.record_partition_graphs)
7410   return _internal_record_partition_graphs();
7411 }
_internal_set_record_partition_graphs(bool value)7412 inline void ExecutorOpts::_internal_set_record_partition_graphs(bool value) {
7413 
7414   _impl_.record_partition_graphs_ = value;
7415 }
set_record_partition_graphs(bool value)7416 inline void ExecutorOpts::set_record_partition_graphs(bool value) {
7417   _internal_set_record_partition_graphs(value);
7418   // @@protoc_insertion_point(field_set:tensorflow.ExecutorOpts.record_partition_graphs)
7419 }
7420 
7421 // bool report_tensor_allocations_upon_oom = 5;
clear_report_tensor_allocations_upon_oom()7422 inline void ExecutorOpts::clear_report_tensor_allocations_upon_oom() {
7423   _impl_.report_tensor_allocations_upon_oom_ = false;
7424 }
_internal_report_tensor_allocations_upon_oom()7425 inline bool ExecutorOpts::_internal_report_tensor_allocations_upon_oom() const {
7426   return _impl_.report_tensor_allocations_upon_oom_;
7427 }
report_tensor_allocations_upon_oom()7428 inline bool ExecutorOpts::report_tensor_allocations_upon_oom() const {
7429   // @@protoc_insertion_point(field_get:tensorflow.ExecutorOpts.report_tensor_allocations_upon_oom)
7430   return _internal_report_tensor_allocations_upon_oom();
7431 }
_internal_set_report_tensor_allocations_upon_oom(bool value)7432 inline void ExecutorOpts::_internal_set_report_tensor_allocations_upon_oom(bool value) {
7433 
7434   _impl_.report_tensor_allocations_upon_oom_ = value;
7435 }
set_report_tensor_allocations_upon_oom(bool value)7436 inline void ExecutorOpts::set_report_tensor_allocations_upon_oom(bool value) {
7437   _internal_set_report_tensor_allocations_upon_oom(value);
7438   // @@protoc_insertion_point(field_set:tensorflow.ExecutorOpts.report_tensor_allocations_upon_oom)
7439 }
7440 
7441 // -------------------------------------------------------------------
7442 
7443 // RunGraphRequest
7444 
7445 // string session_handle = 8;
clear_session_handle()7446 inline void RunGraphRequest::clear_session_handle() {
7447   _impl_.session_handle_.ClearToEmpty();
7448 }
session_handle()7449 inline const std::string& RunGraphRequest::session_handle() const {
7450   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.session_handle)
7451   return _internal_session_handle();
7452 }
7453 template <typename ArgT0, typename... ArgT>
7454 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)7455 void RunGraphRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
7456 
7457  _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7458   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.session_handle)
7459 }
mutable_session_handle()7460 inline std::string* RunGraphRequest::mutable_session_handle() {
7461   std::string* _s = _internal_mutable_session_handle();
7462   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphRequest.session_handle)
7463   return _s;
7464 }
_internal_session_handle()7465 inline const std::string& RunGraphRequest::_internal_session_handle() const {
7466   return _impl_.session_handle_.Get();
7467 }
_internal_set_session_handle(const std::string & value)7468 inline void RunGraphRequest::_internal_set_session_handle(const std::string& value) {
7469 
7470   _impl_.session_handle_.Set(value, GetArenaForAllocation());
7471 }
_internal_mutable_session_handle()7472 inline std::string* RunGraphRequest::_internal_mutable_session_handle() {
7473 
7474   return _impl_.session_handle_.Mutable(GetArenaForAllocation());
7475 }
release_session_handle()7476 inline std::string* RunGraphRequest::release_session_handle() {
7477   // @@protoc_insertion_point(field_release:tensorflow.RunGraphRequest.session_handle)
7478   return _impl_.session_handle_.Release();
7479 }
set_allocated_session_handle(std::string * session_handle)7480 inline void RunGraphRequest::set_allocated_session_handle(std::string* session_handle) {
7481   _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
7482 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7483   if (_impl_.session_handle_.IsDefault()) {
7484     _impl_.session_handle_.Set("", GetArenaForAllocation());
7485   }
7486 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7487   // @@protoc_insertion_point(field_set_allocated:tensorflow.RunGraphRequest.session_handle)
7488 }
7489 
7490 // bool create_worker_session_called = 10;
clear_create_worker_session_called()7491 inline void RunGraphRequest::clear_create_worker_session_called() {
7492   _impl_.create_worker_session_called_ = false;
7493 }
_internal_create_worker_session_called()7494 inline bool RunGraphRequest::_internal_create_worker_session_called() const {
7495   return _impl_.create_worker_session_called_;
7496 }
create_worker_session_called()7497 inline bool RunGraphRequest::create_worker_session_called() const {
7498   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.create_worker_session_called)
7499   return _internal_create_worker_session_called();
7500 }
_internal_set_create_worker_session_called(bool value)7501 inline void RunGraphRequest::_internal_set_create_worker_session_called(bool value) {
7502 
7503   _impl_.create_worker_session_called_ = value;
7504 }
set_create_worker_session_called(bool value)7505 inline void RunGraphRequest::set_create_worker_session_called(bool value) {
7506   _internal_set_create_worker_session_called(value);
7507   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.create_worker_session_called)
7508 }
7509 
7510 // string graph_handle = 1;
clear_graph_handle()7511 inline void RunGraphRequest::clear_graph_handle() {
7512   _impl_.graph_handle_.ClearToEmpty();
7513 }
graph_handle()7514 inline const std::string& RunGraphRequest::graph_handle() const {
7515   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.graph_handle)
7516   return _internal_graph_handle();
7517 }
7518 template <typename ArgT0, typename... ArgT>
7519 inline PROTOBUF_ALWAYS_INLINE
set_graph_handle(ArgT0 && arg0,ArgT...args)7520 void RunGraphRequest::set_graph_handle(ArgT0&& arg0, ArgT... args) {
7521 
7522  _impl_.graph_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
7523   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.graph_handle)
7524 }
mutable_graph_handle()7525 inline std::string* RunGraphRequest::mutable_graph_handle() {
7526   std::string* _s = _internal_mutable_graph_handle();
7527   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphRequest.graph_handle)
7528   return _s;
7529 }
_internal_graph_handle()7530 inline const std::string& RunGraphRequest::_internal_graph_handle() const {
7531   return _impl_.graph_handle_.Get();
7532 }
_internal_set_graph_handle(const std::string & value)7533 inline void RunGraphRequest::_internal_set_graph_handle(const std::string& value) {
7534 
7535   _impl_.graph_handle_.Set(value, GetArenaForAllocation());
7536 }
_internal_mutable_graph_handle()7537 inline std::string* RunGraphRequest::_internal_mutable_graph_handle() {
7538 
7539   return _impl_.graph_handle_.Mutable(GetArenaForAllocation());
7540 }
release_graph_handle()7541 inline std::string* RunGraphRequest::release_graph_handle() {
7542   // @@protoc_insertion_point(field_release:tensorflow.RunGraphRequest.graph_handle)
7543   return _impl_.graph_handle_.Release();
7544 }
set_allocated_graph_handle(std::string * graph_handle)7545 inline void RunGraphRequest::set_allocated_graph_handle(std::string* graph_handle) {
7546   _impl_.graph_handle_.SetAllocated(graph_handle, GetArenaForAllocation());
7547 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
7548   if (_impl_.graph_handle_.IsDefault()) {
7549     _impl_.graph_handle_.Set("", GetArenaForAllocation());
7550   }
7551 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
7552   // @@protoc_insertion_point(field_set_allocated:tensorflow.RunGraphRequest.graph_handle)
7553 }
7554 
7555 // int64 step_id = 2;
clear_step_id()7556 inline void RunGraphRequest::clear_step_id() {
7557   _impl_.step_id_ = ::int64_t{0};
7558 }
_internal_step_id()7559 inline ::int64_t RunGraphRequest::_internal_step_id() const {
7560   return _impl_.step_id_;
7561 }
step_id()7562 inline ::int64_t RunGraphRequest::step_id() const {
7563   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.step_id)
7564   return _internal_step_id();
7565 }
_internal_set_step_id(::int64_t value)7566 inline void RunGraphRequest::_internal_set_step_id(::int64_t value) {
7567 
7568   _impl_.step_id_ = value;
7569 }
set_step_id(::int64_t value)7570 inline void RunGraphRequest::set_step_id(::int64_t value) {
7571   _internal_set_step_id(value);
7572   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.step_id)
7573 }
7574 
7575 // .tensorflow.ExecutorOpts exec_opts = 5;
_internal_has_exec_opts()7576 inline bool RunGraphRequest::_internal_has_exec_opts() const {
7577   return this != internal_default_instance() && _impl_.exec_opts_ != nullptr;
7578 }
has_exec_opts()7579 inline bool RunGraphRequest::has_exec_opts() const {
7580   return _internal_has_exec_opts();
7581 }
clear_exec_opts()7582 inline void RunGraphRequest::clear_exec_opts() {
7583   if (GetArenaForAllocation() == nullptr && _impl_.exec_opts_ != nullptr) {
7584     delete _impl_.exec_opts_;
7585   }
7586   _impl_.exec_opts_ = nullptr;
7587 }
_internal_exec_opts()7588 inline const ::tensorflow::ExecutorOpts& RunGraphRequest::_internal_exec_opts() const {
7589   const ::tensorflow::ExecutorOpts* p = _impl_.exec_opts_;
7590   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::ExecutorOpts&>(
7591       ::tensorflow::_ExecutorOpts_default_instance_);
7592 }
exec_opts()7593 inline const ::tensorflow::ExecutorOpts& RunGraphRequest::exec_opts() const {
7594   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.exec_opts)
7595   return _internal_exec_opts();
7596 }
unsafe_arena_set_allocated_exec_opts(::tensorflow::ExecutorOpts * exec_opts)7597 inline void RunGraphRequest::unsafe_arena_set_allocated_exec_opts(
7598     ::tensorflow::ExecutorOpts* exec_opts) {
7599   if (GetArenaForAllocation() == nullptr) {
7600     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.exec_opts_);
7601   }
7602   _impl_.exec_opts_ = exec_opts;
7603   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RunGraphRequest.exec_opts)
7604 }
release_exec_opts()7605 inline ::tensorflow::ExecutorOpts* RunGraphRequest::release_exec_opts() {
7606 
7607   ::tensorflow::ExecutorOpts* temp = _impl_.exec_opts_;
7608   _impl_.exec_opts_ = nullptr;
7609 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7610   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
7611   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7612   if (GetArenaForAllocation() == nullptr) { delete old; }
7613 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
7614   if (GetArenaForAllocation() != nullptr) {
7615     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7616   }
7617 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7618   return temp;
7619 }
unsafe_arena_release_exec_opts()7620 inline ::tensorflow::ExecutorOpts* RunGraphRequest::unsafe_arena_release_exec_opts() {
7621   // @@protoc_insertion_point(field_release:tensorflow.RunGraphRequest.exec_opts)
7622 
7623   ::tensorflow::ExecutorOpts* temp = _impl_.exec_opts_;
7624   _impl_.exec_opts_ = nullptr;
7625   return temp;
7626 }
_internal_mutable_exec_opts()7627 inline ::tensorflow::ExecutorOpts* RunGraphRequest::_internal_mutable_exec_opts() {
7628 
7629   if (_impl_.exec_opts_ == nullptr) {
7630     auto* p = CreateMaybeMessage<::tensorflow::ExecutorOpts>(GetArenaForAllocation());
7631     _impl_.exec_opts_ = p;
7632   }
7633   return _impl_.exec_opts_;
7634 }
mutable_exec_opts()7635 inline ::tensorflow::ExecutorOpts* RunGraphRequest::mutable_exec_opts() {
7636   ::tensorflow::ExecutorOpts* _msg = _internal_mutable_exec_opts();
7637   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphRequest.exec_opts)
7638   return _msg;
7639 }
set_allocated_exec_opts(::tensorflow::ExecutorOpts * exec_opts)7640 inline void RunGraphRequest::set_allocated_exec_opts(::tensorflow::ExecutorOpts* exec_opts) {
7641   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
7642   if (message_arena == nullptr) {
7643     delete _impl_.exec_opts_;
7644   }
7645   if (exec_opts) {
7646     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
7647         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(exec_opts);
7648     if (message_arena != submessage_arena) {
7649       exec_opts = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7650           message_arena, exec_opts, submessage_arena);
7651     }
7652 
7653   } else {
7654 
7655   }
7656   _impl_.exec_opts_ = exec_opts;
7657   // @@protoc_insertion_point(field_set_allocated:tensorflow.RunGraphRequest.exec_opts)
7658 }
7659 
7660 // repeated .tensorflow.NamedTensorProto send = 3;
_internal_send_size()7661 inline int RunGraphRequest::_internal_send_size() const {
7662   return _impl_.send_.size();
7663 }
send_size()7664 inline int RunGraphRequest::send_size() const {
7665   return _internal_send_size();
7666 }
mutable_send(int index)7667 inline ::tensorflow::NamedTensorProto* RunGraphRequest::mutable_send(int index) {
7668   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphRequest.send)
7669   return _impl_.send_.Mutable(index);
7670 }
7671 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
mutable_send()7672 RunGraphRequest::mutable_send() {
7673   // @@protoc_insertion_point(field_mutable_list:tensorflow.RunGraphRequest.send)
7674   return &_impl_.send_;
7675 }
_internal_send(int index)7676 inline const ::tensorflow::NamedTensorProto& RunGraphRequest::_internal_send(int index) const {
7677   return _impl_.send_.Get(index);
7678 }
send(int index)7679 inline const ::tensorflow::NamedTensorProto& RunGraphRequest::send(int index) const {
7680   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.send)
7681   return _internal_send(index);
7682 }
_internal_add_send()7683 inline ::tensorflow::NamedTensorProto* RunGraphRequest::_internal_add_send() {
7684   return _impl_.send_.Add();
7685 }
add_send()7686 inline ::tensorflow::NamedTensorProto* RunGraphRequest::add_send() {
7687   ::tensorflow::NamedTensorProto* _add = _internal_add_send();
7688   // @@protoc_insertion_point(field_add:tensorflow.RunGraphRequest.send)
7689   return _add;
7690 }
7691 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
send()7692 RunGraphRequest::send() const {
7693   // @@protoc_insertion_point(field_list:tensorflow.RunGraphRequest.send)
7694   return _impl_.send_;
7695 }
7696 
7697 // repeated string recv_key = 4;
_internal_recv_key_size()7698 inline int RunGraphRequest::_internal_recv_key_size() const {
7699   return _impl_.recv_key_.size();
7700 }
recv_key_size()7701 inline int RunGraphRequest::recv_key_size() const {
7702   return _internal_recv_key_size();
7703 }
clear_recv_key()7704 inline void RunGraphRequest::clear_recv_key() {
7705   _impl_.recv_key_.Clear();
7706 }
add_recv_key()7707 inline std::string* RunGraphRequest::add_recv_key() {
7708   std::string* _s = _internal_add_recv_key();
7709   // @@protoc_insertion_point(field_add_mutable:tensorflow.RunGraphRequest.recv_key)
7710   return _s;
7711 }
_internal_recv_key(int index)7712 inline const std::string& RunGraphRequest::_internal_recv_key(int index) const {
7713   return _impl_.recv_key_.Get(index);
7714 }
recv_key(int index)7715 inline const std::string& RunGraphRequest::recv_key(int index) const {
7716   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.recv_key)
7717   return _internal_recv_key(index);
7718 }
mutable_recv_key(int index)7719 inline std::string* RunGraphRequest::mutable_recv_key(int index) {
7720   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphRequest.recv_key)
7721   return _impl_.recv_key_.Mutable(index);
7722 }
set_recv_key(int index,const std::string & value)7723 inline void RunGraphRequest::set_recv_key(int index, const std::string& value) {
7724   _impl_.recv_key_.Mutable(index)->assign(value);
7725   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.recv_key)
7726 }
set_recv_key(int index,std::string && value)7727 inline void RunGraphRequest::set_recv_key(int index, std::string&& value) {
7728   _impl_.recv_key_.Mutable(index)->assign(std::move(value));
7729   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.recv_key)
7730 }
set_recv_key(int index,const char * value)7731 inline void RunGraphRequest::set_recv_key(int index, const char* value) {
7732   GOOGLE_DCHECK(value != nullptr);
7733   _impl_.recv_key_.Mutable(index)->assign(value);
7734   // @@protoc_insertion_point(field_set_char:tensorflow.RunGraphRequest.recv_key)
7735 }
set_recv_key(int index,const char * value,size_t size)7736 inline void RunGraphRequest::set_recv_key(int index, const char* value, size_t size) {
7737   _impl_.recv_key_.Mutable(index)->assign(
7738     reinterpret_cast<const char*>(value), size);
7739   // @@protoc_insertion_point(field_set_pointer:tensorflow.RunGraphRequest.recv_key)
7740 }
_internal_add_recv_key()7741 inline std::string* RunGraphRequest::_internal_add_recv_key() {
7742   return _impl_.recv_key_.Add();
7743 }
add_recv_key(const std::string & value)7744 inline void RunGraphRequest::add_recv_key(const std::string& value) {
7745   _impl_.recv_key_.Add()->assign(value);
7746   // @@protoc_insertion_point(field_add:tensorflow.RunGraphRequest.recv_key)
7747 }
add_recv_key(std::string && value)7748 inline void RunGraphRequest::add_recv_key(std::string&& value) {
7749   _impl_.recv_key_.Add(std::move(value));
7750   // @@protoc_insertion_point(field_add:tensorflow.RunGraphRequest.recv_key)
7751 }
add_recv_key(const char * value)7752 inline void RunGraphRequest::add_recv_key(const char* value) {
7753   GOOGLE_DCHECK(value != nullptr);
7754   _impl_.recv_key_.Add()->assign(value);
7755   // @@protoc_insertion_point(field_add_char:tensorflow.RunGraphRequest.recv_key)
7756 }
add_recv_key(const char * value,size_t size)7757 inline void RunGraphRequest::add_recv_key(const char* value, size_t size) {
7758   _impl_.recv_key_.Add()->assign(reinterpret_cast<const char*>(value), size);
7759   // @@protoc_insertion_point(field_add_pointer:tensorflow.RunGraphRequest.recv_key)
7760 }
7761 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
recv_key()7762 RunGraphRequest::recv_key() const {
7763   // @@protoc_insertion_point(field_list:tensorflow.RunGraphRequest.recv_key)
7764   return _impl_.recv_key_;
7765 }
7766 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_recv_key()7767 RunGraphRequest::mutable_recv_key() {
7768   // @@protoc_insertion_point(field_mutable_list:tensorflow.RunGraphRequest.recv_key)
7769   return &_impl_.recv_key_;
7770 }
7771 
7772 // bool is_partial = 6;
clear_is_partial()7773 inline void RunGraphRequest::clear_is_partial() {
7774   _impl_.is_partial_ = false;
7775 }
_internal_is_partial()7776 inline bool RunGraphRequest::_internal_is_partial() const {
7777   return _impl_.is_partial_;
7778 }
is_partial()7779 inline bool RunGraphRequest::is_partial() const {
7780   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.is_partial)
7781   return _internal_is_partial();
7782 }
_internal_set_is_partial(bool value)7783 inline void RunGraphRequest::_internal_set_is_partial(bool value) {
7784 
7785   _impl_.is_partial_ = value;
7786 }
set_is_partial(bool value)7787 inline void RunGraphRequest::set_is_partial(bool value) {
7788   _internal_set_is_partial(value);
7789   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.is_partial)
7790 }
7791 
7792 // bool is_last_partial_run = 7;
clear_is_last_partial_run()7793 inline void RunGraphRequest::clear_is_last_partial_run() {
7794   _impl_.is_last_partial_run_ = false;
7795 }
_internal_is_last_partial_run()7796 inline bool RunGraphRequest::_internal_is_last_partial_run() const {
7797   return _impl_.is_last_partial_run_;
7798 }
is_last_partial_run()7799 inline bool RunGraphRequest::is_last_partial_run() const {
7800   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.is_last_partial_run)
7801   return _internal_is_last_partial_run();
7802 }
_internal_set_is_last_partial_run(bool value)7803 inline void RunGraphRequest::_internal_set_is_last_partial_run(bool value) {
7804 
7805   _impl_.is_last_partial_run_ = value;
7806 }
set_is_last_partial_run(bool value)7807 inline void RunGraphRequest::set_is_last_partial_run(bool value) {
7808   _internal_set_is_last_partial_run(value);
7809   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.is_last_partial_run)
7810 }
7811 
7812 // bool store_errors_in_response_body = 9;
clear_store_errors_in_response_body()7813 inline void RunGraphRequest::clear_store_errors_in_response_body() {
7814   _impl_.store_errors_in_response_body_ = false;
7815 }
_internal_store_errors_in_response_body()7816 inline bool RunGraphRequest::_internal_store_errors_in_response_body() const {
7817   return _impl_.store_errors_in_response_body_;
7818 }
store_errors_in_response_body()7819 inline bool RunGraphRequest::store_errors_in_response_body() const {
7820   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.store_errors_in_response_body)
7821   return _internal_store_errors_in_response_body();
7822 }
_internal_set_store_errors_in_response_body(bool value)7823 inline void RunGraphRequest::_internal_set_store_errors_in_response_body(bool value) {
7824 
7825   _impl_.store_errors_in_response_body_ = value;
7826 }
set_store_errors_in_response_body(bool value)7827 inline void RunGraphRequest::set_store_errors_in_response_body(bool value) {
7828   _internal_set_store_errors_in_response_body(value);
7829   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.store_errors_in_response_body)
7830 }
7831 
7832 // int64 request_id = 11;
clear_request_id()7833 inline void RunGraphRequest::clear_request_id() {
7834   _impl_.request_id_ = ::int64_t{0};
7835 }
_internal_request_id()7836 inline ::int64_t RunGraphRequest::_internal_request_id() const {
7837   return _impl_.request_id_;
7838 }
request_id()7839 inline ::int64_t RunGraphRequest::request_id() const {
7840   // @@protoc_insertion_point(field_get:tensorflow.RunGraphRequest.request_id)
7841   return _internal_request_id();
7842 }
_internal_set_request_id(::int64_t value)7843 inline void RunGraphRequest::_internal_set_request_id(::int64_t value) {
7844 
7845   _impl_.request_id_ = value;
7846 }
set_request_id(::int64_t value)7847 inline void RunGraphRequest::set_request_id(::int64_t value) {
7848   _internal_set_request_id(value);
7849   // @@protoc_insertion_point(field_set:tensorflow.RunGraphRequest.request_id)
7850 }
7851 
7852 // -------------------------------------------------------------------
7853 
7854 // RunGraphResponse
7855 
7856 // repeated .tensorflow.NamedTensorProto recv = 1;
_internal_recv_size()7857 inline int RunGraphResponse::_internal_recv_size() const {
7858   return _impl_.recv_.size();
7859 }
recv_size()7860 inline int RunGraphResponse::recv_size() const {
7861   return _internal_recv_size();
7862 }
mutable_recv(int index)7863 inline ::tensorflow::NamedTensorProto* RunGraphResponse::mutable_recv(int index) {
7864   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphResponse.recv)
7865   return _impl_.recv_.Mutable(index);
7866 }
7867 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
mutable_recv()7868 RunGraphResponse::mutable_recv() {
7869   // @@protoc_insertion_point(field_mutable_list:tensorflow.RunGraphResponse.recv)
7870   return &_impl_.recv_;
7871 }
_internal_recv(int index)7872 inline const ::tensorflow::NamedTensorProto& RunGraphResponse::_internal_recv(int index) const {
7873   return _impl_.recv_.Get(index);
7874 }
recv(int index)7875 inline const ::tensorflow::NamedTensorProto& RunGraphResponse::recv(int index) const {
7876   // @@protoc_insertion_point(field_get:tensorflow.RunGraphResponse.recv)
7877   return _internal_recv(index);
7878 }
_internal_add_recv()7879 inline ::tensorflow::NamedTensorProto* RunGraphResponse::_internal_add_recv() {
7880   return _impl_.recv_.Add();
7881 }
add_recv()7882 inline ::tensorflow::NamedTensorProto* RunGraphResponse::add_recv() {
7883   ::tensorflow::NamedTensorProto* _add = _internal_add_recv();
7884   // @@protoc_insertion_point(field_add:tensorflow.RunGraphResponse.recv)
7885   return _add;
7886 }
7887 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
recv()7888 RunGraphResponse::recv() const {
7889   // @@protoc_insertion_point(field_list:tensorflow.RunGraphResponse.recv)
7890   return _impl_.recv_;
7891 }
7892 
7893 // .tensorflow.StepStats step_stats = 2;
_internal_has_step_stats()7894 inline bool RunGraphResponse::_internal_has_step_stats() const {
7895   return this != internal_default_instance() && _impl_.step_stats_ != nullptr;
7896 }
has_step_stats()7897 inline bool RunGraphResponse::has_step_stats() const {
7898   return _internal_has_step_stats();
7899 }
_internal_step_stats()7900 inline const ::tensorflow::StepStats& RunGraphResponse::_internal_step_stats() const {
7901   const ::tensorflow::StepStats* p = _impl_.step_stats_;
7902   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::StepStats&>(
7903       ::tensorflow::_StepStats_default_instance_);
7904 }
step_stats()7905 inline const ::tensorflow::StepStats& RunGraphResponse::step_stats() const {
7906   // @@protoc_insertion_point(field_get:tensorflow.RunGraphResponse.step_stats)
7907   return _internal_step_stats();
7908 }
unsafe_arena_set_allocated_step_stats(::tensorflow::StepStats * step_stats)7909 inline void RunGraphResponse::unsafe_arena_set_allocated_step_stats(
7910     ::tensorflow::StepStats* step_stats) {
7911   if (GetArenaForAllocation() == nullptr) {
7912     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.step_stats_);
7913   }
7914   _impl_.step_stats_ = step_stats;
7915   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RunGraphResponse.step_stats)
7916 }
release_step_stats()7917 inline ::tensorflow::StepStats* RunGraphResponse::release_step_stats() {
7918 
7919   ::tensorflow::StepStats* temp = _impl_.step_stats_;
7920   _impl_.step_stats_ = nullptr;
7921 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
7922   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
7923   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7924   if (GetArenaForAllocation() == nullptr) { delete old; }
7925 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
7926   if (GetArenaForAllocation() != nullptr) {
7927     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
7928   }
7929 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
7930   return temp;
7931 }
unsafe_arena_release_step_stats()7932 inline ::tensorflow::StepStats* RunGraphResponse::unsafe_arena_release_step_stats() {
7933   // @@protoc_insertion_point(field_release:tensorflow.RunGraphResponse.step_stats)
7934 
7935   ::tensorflow::StepStats* temp = _impl_.step_stats_;
7936   _impl_.step_stats_ = nullptr;
7937   return temp;
7938 }
_internal_mutable_step_stats()7939 inline ::tensorflow::StepStats* RunGraphResponse::_internal_mutable_step_stats() {
7940 
7941   if (_impl_.step_stats_ == nullptr) {
7942     auto* p = CreateMaybeMessage<::tensorflow::StepStats>(GetArenaForAllocation());
7943     _impl_.step_stats_ = p;
7944   }
7945   return _impl_.step_stats_;
7946 }
mutable_step_stats()7947 inline ::tensorflow::StepStats* RunGraphResponse::mutable_step_stats() {
7948   ::tensorflow::StepStats* _msg = _internal_mutable_step_stats();
7949   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphResponse.step_stats)
7950   return _msg;
7951 }
set_allocated_step_stats(::tensorflow::StepStats * step_stats)7952 inline void RunGraphResponse::set_allocated_step_stats(::tensorflow::StepStats* step_stats) {
7953   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
7954   if (message_arena == nullptr) {
7955     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.step_stats_);
7956   }
7957   if (step_stats) {
7958     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
7959         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
7960                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(step_stats));
7961     if (message_arena != submessage_arena) {
7962       step_stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
7963           message_arena, step_stats, submessage_arena);
7964     }
7965 
7966   } else {
7967 
7968   }
7969   _impl_.step_stats_ = step_stats;
7970   // @@protoc_insertion_point(field_set_allocated:tensorflow.RunGraphResponse.step_stats)
7971 }
7972 
7973 // .tensorflow.CostGraphDef cost_graph = 3;
_internal_has_cost_graph()7974 inline bool RunGraphResponse::_internal_has_cost_graph() const {
7975   return this != internal_default_instance() && _impl_.cost_graph_ != nullptr;
7976 }
has_cost_graph()7977 inline bool RunGraphResponse::has_cost_graph() const {
7978   return _internal_has_cost_graph();
7979 }
_internal_cost_graph()7980 inline const ::tensorflow::CostGraphDef& RunGraphResponse::_internal_cost_graph() const {
7981   const ::tensorflow::CostGraphDef* p = _impl_.cost_graph_;
7982   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::CostGraphDef&>(
7983       ::tensorflow::_CostGraphDef_default_instance_);
7984 }
cost_graph()7985 inline const ::tensorflow::CostGraphDef& RunGraphResponse::cost_graph() const {
7986   // @@protoc_insertion_point(field_get:tensorflow.RunGraphResponse.cost_graph)
7987   return _internal_cost_graph();
7988 }
unsafe_arena_set_allocated_cost_graph(::tensorflow::CostGraphDef * cost_graph)7989 inline void RunGraphResponse::unsafe_arena_set_allocated_cost_graph(
7990     ::tensorflow::CostGraphDef* cost_graph) {
7991   if (GetArenaForAllocation() == nullptr) {
7992     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cost_graph_);
7993   }
7994   _impl_.cost_graph_ = cost_graph;
7995   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RunGraphResponse.cost_graph)
7996 }
release_cost_graph()7997 inline ::tensorflow::CostGraphDef* RunGraphResponse::release_cost_graph() {
7998 
7999   ::tensorflow::CostGraphDef* temp = _impl_.cost_graph_;
8000   _impl_.cost_graph_ = nullptr;
8001 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8002   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8003   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8004   if (GetArenaForAllocation() == nullptr) { delete old; }
8005 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8006   if (GetArenaForAllocation() != nullptr) {
8007     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8008   }
8009 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8010   return temp;
8011 }
unsafe_arena_release_cost_graph()8012 inline ::tensorflow::CostGraphDef* RunGraphResponse::unsafe_arena_release_cost_graph() {
8013   // @@protoc_insertion_point(field_release:tensorflow.RunGraphResponse.cost_graph)
8014 
8015   ::tensorflow::CostGraphDef* temp = _impl_.cost_graph_;
8016   _impl_.cost_graph_ = nullptr;
8017   return temp;
8018 }
_internal_mutable_cost_graph()8019 inline ::tensorflow::CostGraphDef* RunGraphResponse::_internal_mutable_cost_graph() {
8020 
8021   if (_impl_.cost_graph_ == nullptr) {
8022     auto* p = CreateMaybeMessage<::tensorflow::CostGraphDef>(GetArenaForAllocation());
8023     _impl_.cost_graph_ = p;
8024   }
8025   return _impl_.cost_graph_;
8026 }
mutable_cost_graph()8027 inline ::tensorflow::CostGraphDef* RunGraphResponse::mutable_cost_graph() {
8028   ::tensorflow::CostGraphDef* _msg = _internal_mutable_cost_graph();
8029   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphResponse.cost_graph)
8030   return _msg;
8031 }
set_allocated_cost_graph(::tensorflow::CostGraphDef * cost_graph)8032 inline void RunGraphResponse::set_allocated_cost_graph(::tensorflow::CostGraphDef* cost_graph) {
8033   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8034   if (message_arena == nullptr) {
8035     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cost_graph_);
8036   }
8037   if (cost_graph) {
8038     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8039         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8040                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cost_graph));
8041     if (message_arena != submessage_arena) {
8042       cost_graph = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8043           message_arena, cost_graph, submessage_arena);
8044     }
8045 
8046   } else {
8047 
8048   }
8049   _impl_.cost_graph_ = cost_graph;
8050   // @@protoc_insertion_point(field_set_allocated:tensorflow.RunGraphResponse.cost_graph)
8051 }
8052 
8053 // repeated .tensorflow.GraphDef partition_graph = 4;
_internal_partition_graph_size()8054 inline int RunGraphResponse::_internal_partition_graph_size() const {
8055   return _impl_.partition_graph_.size();
8056 }
partition_graph_size()8057 inline int RunGraphResponse::partition_graph_size() const {
8058   return _internal_partition_graph_size();
8059 }
mutable_partition_graph(int index)8060 inline ::tensorflow::GraphDef* RunGraphResponse::mutable_partition_graph(int index) {
8061   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphResponse.partition_graph)
8062   return _impl_.partition_graph_.Mutable(index);
8063 }
8064 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDef >*
mutable_partition_graph()8065 RunGraphResponse::mutable_partition_graph() {
8066   // @@protoc_insertion_point(field_mutable_list:tensorflow.RunGraphResponse.partition_graph)
8067   return &_impl_.partition_graph_;
8068 }
_internal_partition_graph(int index)8069 inline const ::tensorflow::GraphDef& RunGraphResponse::_internal_partition_graph(int index) const {
8070   return _impl_.partition_graph_.Get(index);
8071 }
partition_graph(int index)8072 inline const ::tensorflow::GraphDef& RunGraphResponse::partition_graph(int index) const {
8073   // @@protoc_insertion_point(field_get:tensorflow.RunGraphResponse.partition_graph)
8074   return _internal_partition_graph(index);
8075 }
_internal_add_partition_graph()8076 inline ::tensorflow::GraphDef* RunGraphResponse::_internal_add_partition_graph() {
8077   return _impl_.partition_graph_.Add();
8078 }
add_partition_graph()8079 inline ::tensorflow::GraphDef* RunGraphResponse::add_partition_graph() {
8080   ::tensorflow::GraphDef* _add = _internal_add_partition_graph();
8081   // @@protoc_insertion_point(field_add:tensorflow.RunGraphResponse.partition_graph)
8082   return _add;
8083 }
8084 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::GraphDef >&
partition_graph()8085 RunGraphResponse::partition_graph() const {
8086   // @@protoc_insertion_point(field_list:tensorflow.RunGraphResponse.partition_graph)
8087   return _impl_.partition_graph_;
8088 }
8089 
8090 // .tensorflow.error.Code status_code = 5;
clear_status_code()8091 inline void RunGraphResponse::clear_status_code() {
8092   _impl_.status_code_ = 0;
8093 }
_internal_status_code()8094 inline ::tensorflow::error::Code RunGraphResponse::_internal_status_code() const {
8095   return static_cast< ::tensorflow::error::Code >(_impl_.status_code_);
8096 }
status_code()8097 inline ::tensorflow::error::Code RunGraphResponse::status_code() const {
8098   // @@protoc_insertion_point(field_get:tensorflow.RunGraphResponse.status_code)
8099   return _internal_status_code();
8100 }
_internal_set_status_code(::tensorflow::error::Code value)8101 inline void RunGraphResponse::_internal_set_status_code(::tensorflow::error::Code value) {
8102 
8103   _impl_.status_code_ = value;
8104 }
set_status_code(::tensorflow::error::Code value)8105 inline void RunGraphResponse::set_status_code(::tensorflow::error::Code value) {
8106   _internal_set_status_code(value);
8107   // @@protoc_insertion_point(field_set:tensorflow.RunGraphResponse.status_code)
8108 }
8109 
8110 // string status_error_message = 6;
clear_status_error_message()8111 inline void RunGraphResponse::clear_status_error_message() {
8112   _impl_.status_error_message_.ClearToEmpty();
8113 }
status_error_message()8114 inline const std::string& RunGraphResponse::status_error_message() const {
8115   // @@protoc_insertion_point(field_get:tensorflow.RunGraphResponse.status_error_message)
8116   return _internal_status_error_message();
8117 }
8118 template <typename ArgT0, typename... ArgT>
8119 inline PROTOBUF_ALWAYS_INLINE
set_status_error_message(ArgT0 && arg0,ArgT...args)8120 void RunGraphResponse::set_status_error_message(ArgT0&& arg0, ArgT... args) {
8121 
8122  _impl_.status_error_message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
8123   // @@protoc_insertion_point(field_set:tensorflow.RunGraphResponse.status_error_message)
8124 }
mutable_status_error_message()8125 inline std::string* RunGraphResponse::mutable_status_error_message() {
8126   std::string* _s = _internal_mutable_status_error_message();
8127   // @@protoc_insertion_point(field_mutable:tensorflow.RunGraphResponse.status_error_message)
8128   return _s;
8129 }
_internal_status_error_message()8130 inline const std::string& RunGraphResponse::_internal_status_error_message() const {
8131   return _impl_.status_error_message_.Get();
8132 }
_internal_set_status_error_message(const std::string & value)8133 inline void RunGraphResponse::_internal_set_status_error_message(const std::string& value) {
8134 
8135   _impl_.status_error_message_.Set(value, GetArenaForAllocation());
8136 }
_internal_mutable_status_error_message()8137 inline std::string* RunGraphResponse::_internal_mutable_status_error_message() {
8138 
8139   return _impl_.status_error_message_.Mutable(GetArenaForAllocation());
8140 }
release_status_error_message()8141 inline std::string* RunGraphResponse::release_status_error_message() {
8142   // @@protoc_insertion_point(field_release:tensorflow.RunGraphResponse.status_error_message)
8143   return _impl_.status_error_message_.Release();
8144 }
set_allocated_status_error_message(std::string * status_error_message)8145 inline void RunGraphResponse::set_allocated_status_error_message(std::string* status_error_message) {
8146   _impl_.status_error_message_.SetAllocated(status_error_message, GetArenaForAllocation());
8147 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8148   if (_impl_.status_error_message_.IsDefault()) {
8149     _impl_.status_error_message_.Set("", GetArenaForAllocation());
8150   }
8151 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8152   // @@protoc_insertion_point(field_set_allocated:tensorflow.RunGraphResponse.status_error_message)
8153 }
8154 
8155 // -------------------------------------------------------------------
8156 
8157 // CleanupGraphRequest
8158 
8159 // int64 step_id = 1;
clear_step_id()8160 inline void CleanupGraphRequest::clear_step_id() {
8161   _impl_.step_id_ = ::int64_t{0};
8162 }
_internal_step_id()8163 inline ::int64_t CleanupGraphRequest::_internal_step_id() const {
8164   return _impl_.step_id_;
8165 }
step_id()8166 inline ::int64_t CleanupGraphRequest::step_id() const {
8167   // @@protoc_insertion_point(field_get:tensorflow.CleanupGraphRequest.step_id)
8168   return _internal_step_id();
8169 }
_internal_set_step_id(::int64_t value)8170 inline void CleanupGraphRequest::_internal_set_step_id(::int64_t value) {
8171 
8172   _impl_.step_id_ = value;
8173 }
set_step_id(::int64_t value)8174 inline void CleanupGraphRequest::set_step_id(::int64_t value) {
8175   _internal_set_step_id(value);
8176   // @@protoc_insertion_point(field_set:tensorflow.CleanupGraphRequest.step_id)
8177 }
8178 
8179 // -------------------------------------------------------------------
8180 
8181 // CleanupGraphResponse
8182 
8183 // -------------------------------------------------------------------
8184 
8185 // RecvTensorRequest
8186 
8187 // int64 step_id = 1;
clear_step_id()8188 inline void RecvTensorRequest::clear_step_id() {
8189   _impl_.step_id_ = ::int64_t{0};
8190 }
_internal_step_id()8191 inline ::int64_t RecvTensorRequest::_internal_step_id() const {
8192   return _impl_.step_id_;
8193 }
step_id()8194 inline ::int64_t RecvTensorRequest::step_id() const {
8195   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.step_id)
8196   return _internal_step_id();
8197 }
_internal_set_step_id(::int64_t value)8198 inline void RecvTensorRequest::_internal_set_step_id(::int64_t value) {
8199 
8200   _impl_.step_id_ = value;
8201 }
set_step_id(::int64_t value)8202 inline void RecvTensorRequest::set_step_id(::int64_t value) {
8203   _internal_set_step_id(value);
8204   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorRequest.step_id)
8205 }
8206 
8207 // string rendezvous_key = 2;
clear_rendezvous_key()8208 inline void RecvTensorRequest::clear_rendezvous_key() {
8209   _impl_.rendezvous_key_.ClearToEmpty();
8210 }
rendezvous_key()8211 inline const std::string& RecvTensorRequest::rendezvous_key() const {
8212   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.rendezvous_key)
8213   return _internal_rendezvous_key();
8214 }
8215 template <typename ArgT0, typename... ArgT>
8216 inline PROTOBUF_ALWAYS_INLINE
set_rendezvous_key(ArgT0 && arg0,ArgT...args)8217 void RecvTensorRequest::set_rendezvous_key(ArgT0&& arg0, ArgT... args) {
8218 
8219  _impl_.rendezvous_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
8220   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorRequest.rendezvous_key)
8221 }
mutable_rendezvous_key()8222 inline std::string* RecvTensorRequest::mutable_rendezvous_key() {
8223   std::string* _s = _internal_mutable_rendezvous_key();
8224   // @@protoc_insertion_point(field_mutable:tensorflow.RecvTensorRequest.rendezvous_key)
8225   return _s;
8226 }
_internal_rendezvous_key()8227 inline const std::string& RecvTensorRequest::_internal_rendezvous_key() const {
8228   return _impl_.rendezvous_key_.Get();
8229 }
_internal_set_rendezvous_key(const std::string & value)8230 inline void RecvTensorRequest::_internal_set_rendezvous_key(const std::string& value) {
8231 
8232   _impl_.rendezvous_key_.Set(value, GetArenaForAllocation());
8233 }
_internal_mutable_rendezvous_key()8234 inline std::string* RecvTensorRequest::_internal_mutable_rendezvous_key() {
8235 
8236   return _impl_.rendezvous_key_.Mutable(GetArenaForAllocation());
8237 }
release_rendezvous_key()8238 inline std::string* RecvTensorRequest::release_rendezvous_key() {
8239   // @@protoc_insertion_point(field_release:tensorflow.RecvTensorRequest.rendezvous_key)
8240   return _impl_.rendezvous_key_.Release();
8241 }
set_allocated_rendezvous_key(std::string * rendezvous_key)8242 inline void RecvTensorRequest::set_allocated_rendezvous_key(std::string* rendezvous_key) {
8243   _impl_.rendezvous_key_.SetAllocated(rendezvous_key, GetArenaForAllocation());
8244 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
8245   if (_impl_.rendezvous_key_.IsDefault()) {
8246     _impl_.rendezvous_key_.Set("", GetArenaForAllocation());
8247   }
8248 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
8249   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvTensorRequest.rendezvous_key)
8250 }
8251 
8252 // bool dma_ok = 3;
clear_dma_ok()8253 inline void RecvTensorRequest::clear_dma_ok() {
8254   _impl_.dma_ok_ = false;
8255 }
_internal_dma_ok()8256 inline bool RecvTensorRequest::_internal_dma_ok() const {
8257   return _impl_.dma_ok_;
8258 }
dma_ok()8259 inline bool RecvTensorRequest::dma_ok() const {
8260   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.dma_ok)
8261   return _internal_dma_ok();
8262 }
_internal_set_dma_ok(bool value)8263 inline void RecvTensorRequest::_internal_set_dma_ok(bool value) {
8264 
8265   _impl_.dma_ok_ = value;
8266 }
set_dma_ok(bool value)8267 inline void RecvTensorRequest::set_dma_ok(bool value) {
8268   _internal_set_dma_ok(value);
8269   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorRequest.dma_ok)
8270 }
8271 
8272 // .tensorflow.DeviceLocality client_locality = 4;
_internal_has_client_locality()8273 inline bool RecvTensorRequest::_internal_has_client_locality() const {
8274   return this != internal_default_instance() && _impl_.client_locality_ != nullptr;
8275 }
has_client_locality()8276 inline bool RecvTensorRequest::has_client_locality() const {
8277   return _internal_has_client_locality();
8278 }
_internal_client_locality()8279 inline const ::tensorflow::DeviceLocality& RecvTensorRequest::_internal_client_locality() const {
8280   const ::tensorflow::DeviceLocality* p = _impl_.client_locality_;
8281   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceLocality&>(
8282       ::tensorflow::_DeviceLocality_default_instance_);
8283 }
client_locality()8284 inline const ::tensorflow::DeviceLocality& RecvTensorRequest::client_locality() const {
8285   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.client_locality)
8286   return _internal_client_locality();
8287 }
unsafe_arena_set_allocated_client_locality(::tensorflow::DeviceLocality * client_locality)8288 inline void RecvTensorRequest::unsafe_arena_set_allocated_client_locality(
8289     ::tensorflow::DeviceLocality* client_locality) {
8290   if (GetArenaForAllocation() == nullptr) {
8291     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_locality_);
8292   }
8293   _impl_.client_locality_ = client_locality;
8294   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvTensorRequest.client_locality)
8295 }
release_client_locality()8296 inline ::tensorflow::DeviceLocality* RecvTensorRequest::release_client_locality() {
8297 
8298   ::tensorflow::DeviceLocality* temp = _impl_.client_locality_;
8299   _impl_.client_locality_ = nullptr;
8300 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8301   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8302   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8303   if (GetArenaForAllocation() == nullptr) { delete old; }
8304 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8305   if (GetArenaForAllocation() != nullptr) {
8306     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8307   }
8308 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8309   return temp;
8310 }
unsafe_arena_release_client_locality()8311 inline ::tensorflow::DeviceLocality* RecvTensorRequest::unsafe_arena_release_client_locality() {
8312   // @@protoc_insertion_point(field_release:tensorflow.RecvTensorRequest.client_locality)
8313 
8314   ::tensorflow::DeviceLocality* temp = _impl_.client_locality_;
8315   _impl_.client_locality_ = nullptr;
8316   return temp;
8317 }
_internal_mutable_client_locality()8318 inline ::tensorflow::DeviceLocality* RecvTensorRequest::_internal_mutable_client_locality() {
8319 
8320   if (_impl_.client_locality_ == nullptr) {
8321     auto* p = CreateMaybeMessage<::tensorflow::DeviceLocality>(GetArenaForAllocation());
8322     _impl_.client_locality_ = p;
8323   }
8324   return _impl_.client_locality_;
8325 }
mutable_client_locality()8326 inline ::tensorflow::DeviceLocality* RecvTensorRequest::mutable_client_locality() {
8327   ::tensorflow::DeviceLocality* _msg = _internal_mutable_client_locality();
8328   // @@protoc_insertion_point(field_mutable:tensorflow.RecvTensorRequest.client_locality)
8329   return _msg;
8330 }
set_allocated_client_locality(::tensorflow::DeviceLocality * client_locality)8331 inline void RecvTensorRequest::set_allocated_client_locality(::tensorflow::DeviceLocality* client_locality) {
8332   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8333   if (message_arena == nullptr) {
8334     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_locality_);
8335   }
8336   if (client_locality) {
8337     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8338         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8339                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_locality));
8340     if (message_arena != submessage_arena) {
8341       client_locality = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8342           message_arena, client_locality, submessage_arena);
8343     }
8344 
8345   } else {
8346 
8347   }
8348   _impl_.client_locality_ = client_locality;
8349   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvTensorRequest.client_locality)
8350 }
8351 
8352 // .tensorflow.DeviceLocality server_locality = 5;
_internal_has_server_locality()8353 inline bool RecvTensorRequest::_internal_has_server_locality() const {
8354   return this != internal_default_instance() && _impl_.server_locality_ != nullptr;
8355 }
has_server_locality()8356 inline bool RecvTensorRequest::has_server_locality() const {
8357   return _internal_has_server_locality();
8358 }
_internal_server_locality()8359 inline const ::tensorflow::DeviceLocality& RecvTensorRequest::_internal_server_locality() const {
8360   const ::tensorflow::DeviceLocality* p = _impl_.server_locality_;
8361   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceLocality&>(
8362       ::tensorflow::_DeviceLocality_default_instance_);
8363 }
server_locality()8364 inline const ::tensorflow::DeviceLocality& RecvTensorRequest::server_locality() const {
8365   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.server_locality)
8366   return _internal_server_locality();
8367 }
unsafe_arena_set_allocated_server_locality(::tensorflow::DeviceLocality * server_locality)8368 inline void RecvTensorRequest::unsafe_arena_set_allocated_server_locality(
8369     ::tensorflow::DeviceLocality* server_locality) {
8370   if (GetArenaForAllocation() == nullptr) {
8371     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_locality_);
8372   }
8373   _impl_.server_locality_ = server_locality;
8374   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvTensorRequest.server_locality)
8375 }
release_server_locality()8376 inline ::tensorflow::DeviceLocality* RecvTensorRequest::release_server_locality() {
8377 
8378   ::tensorflow::DeviceLocality* temp = _impl_.server_locality_;
8379   _impl_.server_locality_ = nullptr;
8380 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8381   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8382   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8383   if (GetArenaForAllocation() == nullptr) { delete old; }
8384 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8385   if (GetArenaForAllocation() != nullptr) {
8386     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8387   }
8388 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8389   return temp;
8390 }
unsafe_arena_release_server_locality()8391 inline ::tensorflow::DeviceLocality* RecvTensorRequest::unsafe_arena_release_server_locality() {
8392   // @@protoc_insertion_point(field_release:tensorflow.RecvTensorRequest.server_locality)
8393 
8394   ::tensorflow::DeviceLocality* temp = _impl_.server_locality_;
8395   _impl_.server_locality_ = nullptr;
8396   return temp;
8397 }
_internal_mutable_server_locality()8398 inline ::tensorflow::DeviceLocality* RecvTensorRequest::_internal_mutable_server_locality() {
8399 
8400   if (_impl_.server_locality_ == nullptr) {
8401     auto* p = CreateMaybeMessage<::tensorflow::DeviceLocality>(GetArenaForAllocation());
8402     _impl_.server_locality_ = p;
8403   }
8404   return _impl_.server_locality_;
8405 }
mutable_server_locality()8406 inline ::tensorflow::DeviceLocality* RecvTensorRequest::mutable_server_locality() {
8407   ::tensorflow::DeviceLocality* _msg = _internal_mutable_server_locality();
8408   // @@protoc_insertion_point(field_mutable:tensorflow.RecvTensorRequest.server_locality)
8409   return _msg;
8410 }
set_allocated_server_locality(::tensorflow::DeviceLocality * server_locality)8411 inline void RecvTensorRequest::set_allocated_server_locality(::tensorflow::DeviceLocality* server_locality) {
8412   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8413   if (message_arena == nullptr) {
8414     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_locality_);
8415   }
8416   if (server_locality) {
8417     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8418         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8419                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(server_locality));
8420     if (message_arena != submessage_arena) {
8421       server_locality = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8422           message_arena, server_locality, submessage_arena);
8423     }
8424 
8425   } else {
8426 
8427   }
8428   _impl_.server_locality_ = server_locality;
8429   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvTensorRequest.server_locality)
8430 }
8431 
8432 // .google.protobuf.Any transport_options = 6;
_internal_has_transport_options()8433 inline bool RecvTensorRequest::_internal_has_transport_options() const {
8434   return this != internal_default_instance() && _impl_.transport_options_ != nullptr;
8435 }
has_transport_options()8436 inline bool RecvTensorRequest::has_transport_options() const {
8437   return _internal_has_transport_options();
8438 }
_internal_transport_options()8439 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvTensorRequest::_internal_transport_options() const {
8440   const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.transport_options_;
8441   return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
8442       ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
8443 }
transport_options()8444 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvTensorRequest::transport_options() const {
8445   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.transport_options)
8446   return _internal_transport_options();
8447 }
unsafe_arena_set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)8448 inline void RecvTensorRequest::unsafe_arena_set_allocated_transport_options(
8449     ::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
8450   if (GetArenaForAllocation() == nullptr) {
8451     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
8452   }
8453   _impl_.transport_options_ = transport_options;
8454   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvTensorRequest.transport_options)
8455 }
release_transport_options()8456 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorRequest::release_transport_options() {
8457 
8458   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
8459   _impl_.transport_options_ = nullptr;
8460 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8461   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8462   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8463   if (GetArenaForAllocation() == nullptr) { delete old; }
8464 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8465   if (GetArenaForAllocation() != nullptr) {
8466     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8467   }
8468 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8469   return temp;
8470 }
unsafe_arena_release_transport_options()8471 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorRequest::unsafe_arena_release_transport_options() {
8472   // @@protoc_insertion_point(field_release:tensorflow.RecvTensorRequest.transport_options)
8473 
8474   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
8475   _impl_.transport_options_ = nullptr;
8476   return temp;
8477 }
_internal_mutable_transport_options()8478 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorRequest::_internal_mutable_transport_options() {
8479 
8480   if (_impl_.transport_options_ == nullptr) {
8481     auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
8482     _impl_.transport_options_ = p;
8483   }
8484   return _impl_.transport_options_;
8485 }
mutable_transport_options()8486 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorRequest::mutable_transport_options() {
8487   ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_transport_options();
8488   // @@protoc_insertion_point(field_mutable:tensorflow.RecvTensorRequest.transport_options)
8489   return _msg;
8490 }
set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)8491 inline void RecvTensorRequest::set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
8492   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8493   if (message_arena == nullptr) {
8494     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
8495   }
8496   if (transport_options) {
8497     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8498         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8499                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transport_options));
8500     if (message_arena != submessage_arena) {
8501       transport_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8502           message_arena, transport_options, submessage_arena);
8503     }
8504 
8505   } else {
8506 
8507   }
8508   _impl_.transport_options_ = transport_options;
8509   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvTensorRequest.transport_options)
8510 }
8511 
8512 // int64 request_id = 7;
clear_request_id()8513 inline void RecvTensorRequest::clear_request_id() {
8514   _impl_.request_id_ = ::int64_t{0};
8515 }
_internal_request_id()8516 inline ::int64_t RecvTensorRequest::_internal_request_id() const {
8517   return _impl_.request_id_;
8518 }
request_id()8519 inline ::int64_t RecvTensorRequest::request_id() const {
8520   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorRequest.request_id)
8521   return _internal_request_id();
8522 }
_internal_set_request_id(::int64_t value)8523 inline void RecvTensorRequest::_internal_set_request_id(::int64_t value) {
8524 
8525   _impl_.request_id_ = value;
8526 }
set_request_id(::int64_t value)8527 inline void RecvTensorRequest::set_request_id(::int64_t value) {
8528   _internal_set_request_id(value);
8529   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorRequest.request_id)
8530 }
8531 
8532 // -------------------------------------------------------------------
8533 
8534 // RecvTensorResponse
8535 
8536 // .tensorflow.TensorProto tensor = 1;
_internal_has_tensor()8537 inline bool RecvTensorResponse::_internal_has_tensor() const {
8538   return this != internal_default_instance() && _impl_.tensor_ != nullptr;
8539 }
has_tensor()8540 inline bool RecvTensorResponse::has_tensor() const {
8541   return _internal_has_tensor();
8542 }
_internal_tensor()8543 inline const ::tensorflow::TensorProto& RecvTensorResponse::_internal_tensor() const {
8544   const ::tensorflow::TensorProto* p = _impl_.tensor_;
8545   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorProto&>(
8546       ::tensorflow::_TensorProto_default_instance_);
8547 }
tensor()8548 inline const ::tensorflow::TensorProto& RecvTensorResponse::tensor() const {
8549   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorResponse.tensor)
8550   return _internal_tensor();
8551 }
unsafe_arena_set_allocated_tensor(::tensorflow::TensorProto * tensor)8552 inline void RecvTensorResponse::unsafe_arena_set_allocated_tensor(
8553     ::tensorflow::TensorProto* tensor) {
8554   if (GetArenaForAllocation() == nullptr) {
8555     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
8556   }
8557   _impl_.tensor_ = tensor;
8558   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvTensorResponse.tensor)
8559 }
release_tensor()8560 inline ::tensorflow::TensorProto* RecvTensorResponse::release_tensor() {
8561 
8562   ::tensorflow::TensorProto* temp = _impl_.tensor_;
8563   _impl_.tensor_ = nullptr;
8564 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8565   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8566   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8567   if (GetArenaForAllocation() == nullptr) { delete old; }
8568 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8569   if (GetArenaForAllocation() != nullptr) {
8570     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8571   }
8572 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8573   return temp;
8574 }
unsafe_arena_release_tensor()8575 inline ::tensorflow::TensorProto* RecvTensorResponse::unsafe_arena_release_tensor() {
8576   // @@protoc_insertion_point(field_release:tensorflow.RecvTensorResponse.tensor)
8577 
8578   ::tensorflow::TensorProto* temp = _impl_.tensor_;
8579   _impl_.tensor_ = nullptr;
8580   return temp;
8581 }
_internal_mutable_tensor()8582 inline ::tensorflow::TensorProto* RecvTensorResponse::_internal_mutable_tensor() {
8583 
8584   if (_impl_.tensor_ == nullptr) {
8585     auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaForAllocation());
8586     _impl_.tensor_ = p;
8587   }
8588   return _impl_.tensor_;
8589 }
mutable_tensor()8590 inline ::tensorflow::TensorProto* RecvTensorResponse::mutable_tensor() {
8591   ::tensorflow::TensorProto* _msg = _internal_mutable_tensor();
8592   // @@protoc_insertion_point(field_mutable:tensorflow.RecvTensorResponse.tensor)
8593   return _msg;
8594 }
set_allocated_tensor(::tensorflow::TensorProto * tensor)8595 inline void RecvTensorResponse::set_allocated_tensor(::tensorflow::TensorProto* tensor) {
8596   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8597   if (message_arena == nullptr) {
8598     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.tensor_);
8599   }
8600   if (tensor) {
8601     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8602         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8603                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor));
8604     if (message_arena != submessage_arena) {
8605       tensor = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8606           message_arena, tensor, submessage_arena);
8607     }
8608 
8609   } else {
8610 
8611   }
8612   _impl_.tensor_ = tensor;
8613   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvTensorResponse.tensor)
8614 }
8615 
8616 // bool is_dead = 2;
clear_is_dead()8617 inline void RecvTensorResponse::clear_is_dead() {
8618   _impl_.is_dead_ = false;
8619 }
_internal_is_dead()8620 inline bool RecvTensorResponse::_internal_is_dead() const {
8621   return _impl_.is_dead_;
8622 }
is_dead()8623 inline bool RecvTensorResponse::is_dead() const {
8624   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorResponse.is_dead)
8625   return _internal_is_dead();
8626 }
_internal_set_is_dead(bool value)8627 inline void RecvTensorResponse::_internal_set_is_dead(bool value) {
8628 
8629   _impl_.is_dead_ = value;
8630 }
set_is_dead(bool value)8631 inline void RecvTensorResponse::set_is_dead(bool value) {
8632   _internal_set_is_dead(value);
8633   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorResponse.is_dead)
8634 }
8635 
8636 // int64 send_start_micros = 3;
clear_send_start_micros()8637 inline void RecvTensorResponse::clear_send_start_micros() {
8638   _impl_.send_start_micros_ = ::int64_t{0};
8639 }
_internal_send_start_micros()8640 inline ::int64_t RecvTensorResponse::_internal_send_start_micros() const {
8641   return _impl_.send_start_micros_;
8642 }
send_start_micros()8643 inline ::int64_t RecvTensorResponse::send_start_micros() const {
8644   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorResponse.send_start_micros)
8645   return _internal_send_start_micros();
8646 }
_internal_set_send_start_micros(::int64_t value)8647 inline void RecvTensorResponse::_internal_set_send_start_micros(::int64_t value) {
8648 
8649   _impl_.send_start_micros_ = value;
8650 }
set_send_start_micros(::int64_t value)8651 inline void RecvTensorResponse::set_send_start_micros(::int64_t value) {
8652   _internal_set_send_start_micros(value);
8653   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorResponse.send_start_micros)
8654 }
8655 
8656 // .google.protobuf.Any transport_options = 4;
_internal_has_transport_options()8657 inline bool RecvTensorResponse::_internal_has_transport_options() const {
8658   return this != internal_default_instance() && _impl_.transport_options_ != nullptr;
8659 }
has_transport_options()8660 inline bool RecvTensorResponse::has_transport_options() const {
8661   return _internal_has_transport_options();
8662 }
_internal_transport_options()8663 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvTensorResponse::_internal_transport_options() const {
8664   const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.transport_options_;
8665   return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
8666       ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
8667 }
transport_options()8668 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvTensorResponse::transport_options() const {
8669   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorResponse.transport_options)
8670   return _internal_transport_options();
8671 }
unsafe_arena_set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)8672 inline void RecvTensorResponse::unsafe_arena_set_allocated_transport_options(
8673     ::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
8674   if (GetArenaForAllocation() == nullptr) {
8675     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
8676   }
8677   _impl_.transport_options_ = transport_options;
8678   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvTensorResponse.transport_options)
8679 }
release_transport_options()8680 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorResponse::release_transport_options() {
8681 
8682   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
8683   _impl_.transport_options_ = nullptr;
8684 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8685   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8686   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8687   if (GetArenaForAllocation() == nullptr) { delete old; }
8688 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8689   if (GetArenaForAllocation() != nullptr) {
8690     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8691   }
8692 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8693   return temp;
8694 }
unsafe_arena_release_transport_options()8695 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorResponse::unsafe_arena_release_transport_options() {
8696   // @@protoc_insertion_point(field_release:tensorflow.RecvTensorResponse.transport_options)
8697 
8698   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
8699   _impl_.transport_options_ = nullptr;
8700   return temp;
8701 }
_internal_mutable_transport_options()8702 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorResponse::_internal_mutable_transport_options() {
8703 
8704   if (_impl_.transport_options_ == nullptr) {
8705     auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
8706     _impl_.transport_options_ = p;
8707   }
8708   return _impl_.transport_options_;
8709 }
mutable_transport_options()8710 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvTensorResponse::mutable_transport_options() {
8711   ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_transport_options();
8712   // @@protoc_insertion_point(field_mutable:tensorflow.RecvTensorResponse.transport_options)
8713   return _msg;
8714 }
set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)8715 inline void RecvTensorResponse::set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
8716   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8717   if (message_arena == nullptr) {
8718     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
8719   }
8720   if (transport_options) {
8721     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8722         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8723                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transport_options));
8724     if (message_arena != submessage_arena) {
8725       transport_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8726           message_arena, transport_options, submessage_arena);
8727     }
8728 
8729   } else {
8730 
8731   }
8732   _impl_.transport_options_ = transport_options;
8733   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvTensorResponse.transport_options)
8734 }
8735 
8736 // bool require_ack = 5;
clear_require_ack()8737 inline void RecvTensorResponse::clear_require_ack() {
8738   _impl_.require_ack_ = false;
8739 }
_internal_require_ack()8740 inline bool RecvTensorResponse::_internal_require_ack() const {
8741   return _impl_.require_ack_;
8742 }
require_ack()8743 inline bool RecvTensorResponse::require_ack() const {
8744   // @@protoc_insertion_point(field_get:tensorflow.RecvTensorResponse.require_ack)
8745   return _internal_require_ack();
8746 }
_internal_set_require_ack(bool value)8747 inline void RecvTensorResponse::_internal_set_require_ack(bool value) {
8748 
8749   _impl_.require_ack_ = value;
8750 }
set_require_ack(bool value)8751 inline void RecvTensorResponse::set_require_ack(bool value) {
8752   _internal_set_require_ack(value);
8753   // @@protoc_insertion_point(field_set:tensorflow.RecvTensorResponse.require_ack)
8754 }
8755 
8756 // -------------------------------------------------------------------
8757 
8758 // MarkRecvFinishedRequest
8759 
8760 // int64 request_id = 1;
clear_request_id()8761 inline void MarkRecvFinishedRequest::clear_request_id() {
8762   _impl_.request_id_ = ::int64_t{0};
8763 }
_internal_request_id()8764 inline ::int64_t MarkRecvFinishedRequest::_internal_request_id() const {
8765   return _impl_.request_id_;
8766 }
request_id()8767 inline ::int64_t MarkRecvFinishedRequest::request_id() const {
8768   // @@protoc_insertion_point(field_get:tensorflow.MarkRecvFinishedRequest.request_id)
8769   return _internal_request_id();
8770 }
_internal_set_request_id(::int64_t value)8771 inline void MarkRecvFinishedRequest::_internal_set_request_id(::int64_t value) {
8772 
8773   _impl_.request_id_ = value;
8774 }
set_request_id(::int64_t value)8775 inline void MarkRecvFinishedRequest::set_request_id(::int64_t value) {
8776   _internal_set_request_id(value);
8777   // @@protoc_insertion_point(field_set:tensorflow.MarkRecvFinishedRequest.request_id)
8778 }
8779 
8780 // -------------------------------------------------------------------
8781 
8782 // MarkRecvFinishedResponse
8783 
8784 // -------------------------------------------------------------------
8785 
8786 // LoggingRequest
8787 
8788 // bool enable_rpc_logging = 1;
clear_enable_rpc_logging()8789 inline void LoggingRequest::clear_enable_rpc_logging() {
8790   _impl_.enable_rpc_logging_ = false;
8791 }
_internal_enable_rpc_logging()8792 inline bool LoggingRequest::_internal_enable_rpc_logging() const {
8793   return _impl_.enable_rpc_logging_;
8794 }
enable_rpc_logging()8795 inline bool LoggingRequest::enable_rpc_logging() const {
8796   // @@protoc_insertion_point(field_get:tensorflow.LoggingRequest.enable_rpc_logging)
8797   return _internal_enable_rpc_logging();
8798 }
_internal_set_enable_rpc_logging(bool value)8799 inline void LoggingRequest::_internal_set_enable_rpc_logging(bool value) {
8800 
8801   _impl_.enable_rpc_logging_ = value;
8802 }
set_enable_rpc_logging(bool value)8803 inline void LoggingRequest::set_enable_rpc_logging(bool value) {
8804   _internal_set_enable_rpc_logging(value);
8805   // @@protoc_insertion_point(field_set:tensorflow.LoggingRequest.enable_rpc_logging)
8806 }
8807 
8808 // bool disable_rpc_logging = 4;
clear_disable_rpc_logging()8809 inline void LoggingRequest::clear_disable_rpc_logging() {
8810   _impl_.disable_rpc_logging_ = false;
8811 }
_internal_disable_rpc_logging()8812 inline bool LoggingRequest::_internal_disable_rpc_logging() const {
8813   return _impl_.disable_rpc_logging_;
8814 }
disable_rpc_logging()8815 inline bool LoggingRequest::disable_rpc_logging() const {
8816   // @@protoc_insertion_point(field_get:tensorflow.LoggingRequest.disable_rpc_logging)
8817   return _internal_disable_rpc_logging();
8818 }
_internal_set_disable_rpc_logging(bool value)8819 inline void LoggingRequest::_internal_set_disable_rpc_logging(bool value) {
8820 
8821   _impl_.disable_rpc_logging_ = value;
8822 }
set_disable_rpc_logging(bool value)8823 inline void LoggingRequest::set_disable_rpc_logging(bool value) {
8824   _internal_set_disable_rpc_logging(value);
8825   // @@protoc_insertion_point(field_set:tensorflow.LoggingRequest.disable_rpc_logging)
8826 }
8827 
8828 // bool clear = 2;
clear_clear()8829 inline void LoggingRequest::clear_clear() {
8830   _impl_.clear_ = false;
8831 }
_internal_clear()8832 inline bool LoggingRequest::_internal_clear() const {
8833   return _impl_.clear_;
8834 }
clear()8835 inline bool LoggingRequest::clear() const {
8836   // @@protoc_insertion_point(field_get:tensorflow.LoggingRequest.clear)
8837   return _internal_clear();
8838 }
_internal_set_clear(bool value)8839 inline void LoggingRequest::_internal_set_clear(bool value) {
8840 
8841   _impl_.clear_ = value;
8842 }
set_clear(bool value)8843 inline void LoggingRequest::set_clear(bool value) {
8844   _internal_set_clear(value);
8845   // @@protoc_insertion_point(field_set:tensorflow.LoggingRequest.clear)
8846 }
8847 
8848 // repeated int64 fetch_step_id = 3;
_internal_fetch_step_id_size()8849 inline int LoggingRequest::_internal_fetch_step_id_size() const {
8850   return _impl_.fetch_step_id_.size();
8851 }
fetch_step_id_size()8852 inline int LoggingRequest::fetch_step_id_size() const {
8853   return _internal_fetch_step_id_size();
8854 }
clear_fetch_step_id()8855 inline void LoggingRequest::clear_fetch_step_id() {
8856   _impl_.fetch_step_id_.Clear();
8857 }
_internal_fetch_step_id(int index)8858 inline ::int64_t LoggingRequest::_internal_fetch_step_id(int index) const {
8859   return _impl_.fetch_step_id_.Get(index);
8860 }
fetch_step_id(int index)8861 inline ::int64_t LoggingRequest::fetch_step_id(int index) const {
8862   // @@protoc_insertion_point(field_get:tensorflow.LoggingRequest.fetch_step_id)
8863   return _internal_fetch_step_id(index);
8864 }
set_fetch_step_id(int index,::int64_t value)8865 inline void LoggingRequest::set_fetch_step_id(int index, ::int64_t value) {
8866   _impl_.fetch_step_id_.Set(index, value);
8867   // @@protoc_insertion_point(field_set:tensorflow.LoggingRequest.fetch_step_id)
8868 }
_internal_add_fetch_step_id(::int64_t value)8869 inline void LoggingRequest::_internal_add_fetch_step_id(::int64_t value) {
8870   _impl_.fetch_step_id_.Add(value);
8871 }
add_fetch_step_id(::int64_t value)8872 inline void LoggingRequest::add_fetch_step_id(::int64_t value) {
8873   _internal_add_fetch_step_id(value);
8874   // @@protoc_insertion_point(field_add:tensorflow.LoggingRequest.fetch_step_id)
8875 }
8876 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_fetch_step_id()8877 LoggingRequest::_internal_fetch_step_id() const {
8878   return _impl_.fetch_step_id_;
8879 }
8880 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
fetch_step_id()8881 LoggingRequest::fetch_step_id() const {
8882   // @@protoc_insertion_point(field_list:tensorflow.LoggingRequest.fetch_step_id)
8883   return _internal_fetch_step_id();
8884 }
8885 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_fetch_step_id()8886 LoggingRequest::_internal_mutable_fetch_step_id() {
8887   return &_impl_.fetch_step_id_;
8888 }
8889 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_fetch_step_id()8890 LoggingRequest::mutable_fetch_step_id() {
8891   // @@protoc_insertion_point(field_mutable_list:tensorflow.LoggingRequest.fetch_step_id)
8892   return _internal_mutable_fetch_step_id();
8893 }
8894 
8895 // -------------------------------------------------------------------
8896 
8897 // LabeledStepStats
8898 
8899 // int64 step_id = 1;
clear_step_id()8900 inline void LabeledStepStats::clear_step_id() {
8901   _impl_.step_id_ = ::int64_t{0};
8902 }
_internal_step_id()8903 inline ::int64_t LabeledStepStats::_internal_step_id() const {
8904   return _impl_.step_id_;
8905 }
step_id()8906 inline ::int64_t LabeledStepStats::step_id() const {
8907   // @@protoc_insertion_point(field_get:tensorflow.LabeledStepStats.step_id)
8908   return _internal_step_id();
8909 }
_internal_set_step_id(::int64_t value)8910 inline void LabeledStepStats::_internal_set_step_id(::int64_t value) {
8911 
8912   _impl_.step_id_ = value;
8913 }
set_step_id(::int64_t value)8914 inline void LabeledStepStats::set_step_id(::int64_t value) {
8915   _internal_set_step_id(value);
8916   // @@protoc_insertion_point(field_set:tensorflow.LabeledStepStats.step_id)
8917 }
8918 
8919 // .tensorflow.StepStats step_stats = 2;
_internal_has_step_stats()8920 inline bool LabeledStepStats::_internal_has_step_stats() const {
8921   return this != internal_default_instance() && _impl_.step_stats_ != nullptr;
8922 }
has_step_stats()8923 inline bool LabeledStepStats::has_step_stats() const {
8924   return _internal_has_step_stats();
8925 }
_internal_step_stats()8926 inline const ::tensorflow::StepStats& LabeledStepStats::_internal_step_stats() const {
8927   const ::tensorflow::StepStats* p = _impl_.step_stats_;
8928   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::StepStats&>(
8929       ::tensorflow::_StepStats_default_instance_);
8930 }
step_stats()8931 inline const ::tensorflow::StepStats& LabeledStepStats::step_stats() const {
8932   // @@protoc_insertion_point(field_get:tensorflow.LabeledStepStats.step_stats)
8933   return _internal_step_stats();
8934 }
unsafe_arena_set_allocated_step_stats(::tensorflow::StepStats * step_stats)8935 inline void LabeledStepStats::unsafe_arena_set_allocated_step_stats(
8936     ::tensorflow::StepStats* step_stats) {
8937   if (GetArenaForAllocation() == nullptr) {
8938     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.step_stats_);
8939   }
8940   _impl_.step_stats_ = step_stats;
8941   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.LabeledStepStats.step_stats)
8942 }
release_step_stats()8943 inline ::tensorflow::StepStats* LabeledStepStats::release_step_stats() {
8944 
8945   ::tensorflow::StepStats* temp = _impl_.step_stats_;
8946   _impl_.step_stats_ = nullptr;
8947 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
8948   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
8949   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8950   if (GetArenaForAllocation() == nullptr) { delete old; }
8951 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
8952   if (GetArenaForAllocation() != nullptr) {
8953     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
8954   }
8955 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
8956   return temp;
8957 }
unsafe_arena_release_step_stats()8958 inline ::tensorflow::StepStats* LabeledStepStats::unsafe_arena_release_step_stats() {
8959   // @@protoc_insertion_point(field_release:tensorflow.LabeledStepStats.step_stats)
8960 
8961   ::tensorflow::StepStats* temp = _impl_.step_stats_;
8962   _impl_.step_stats_ = nullptr;
8963   return temp;
8964 }
_internal_mutable_step_stats()8965 inline ::tensorflow::StepStats* LabeledStepStats::_internal_mutable_step_stats() {
8966 
8967   if (_impl_.step_stats_ == nullptr) {
8968     auto* p = CreateMaybeMessage<::tensorflow::StepStats>(GetArenaForAllocation());
8969     _impl_.step_stats_ = p;
8970   }
8971   return _impl_.step_stats_;
8972 }
mutable_step_stats()8973 inline ::tensorflow::StepStats* LabeledStepStats::mutable_step_stats() {
8974   ::tensorflow::StepStats* _msg = _internal_mutable_step_stats();
8975   // @@protoc_insertion_point(field_mutable:tensorflow.LabeledStepStats.step_stats)
8976   return _msg;
8977 }
set_allocated_step_stats(::tensorflow::StepStats * step_stats)8978 inline void LabeledStepStats::set_allocated_step_stats(::tensorflow::StepStats* step_stats) {
8979   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
8980   if (message_arena == nullptr) {
8981     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.step_stats_);
8982   }
8983   if (step_stats) {
8984     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
8985         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
8986                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(step_stats));
8987     if (message_arena != submessage_arena) {
8988       step_stats = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
8989           message_arena, step_stats, submessage_arena);
8990     }
8991 
8992   } else {
8993 
8994   }
8995   _impl_.step_stats_ = step_stats;
8996   // @@protoc_insertion_point(field_set_allocated:tensorflow.LabeledStepStats.step_stats)
8997 }
8998 
8999 // -------------------------------------------------------------------
9000 
9001 // LoggingResponse
9002 
9003 // repeated .tensorflow.LabeledStepStats step = 1;
_internal_step_size()9004 inline int LoggingResponse::_internal_step_size() const {
9005   return _impl_.step_.size();
9006 }
step_size()9007 inline int LoggingResponse::step_size() const {
9008   return _internal_step_size();
9009 }
clear_step()9010 inline void LoggingResponse::clear_step() {
9011   _impl_.step_.Clear();
9012 }
mutable_step(int index)9013 inline ::tensorflow::LabeledStepStats* LoggingResponse::mutable_step(int index) {
9014   // @@protoc_insertion_point(field_mutable:tensorflow.LoggingResponse.step)
9015   return _impl_.step_.Mutable(index);
9016 }
9017 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::LabeledStepStats >*
mutable_step()9018 LoggingResponse::mutable_step() {
9019   // @@protoc_insertion_point(field_mutable_list:tensorflow.LoggingResponse.step)
9020   return &_impl_.step_;
9021 }
_internal_step(int index)9022 inline const ::tensorflow::LabeledStepStats& LoggingResponse::_internal_step(int index) const {
9023   return _impl_.step_.Get(index);
9024 }
step(int index)9025 inline const ::tensorflow::LabeledStepStats& LoggingResponse::step(int index) const {
9026   // @@protoc_insertion_point(field_get:tensorflow.LoggingResponse.step)
9027   return _internal_step(index);
9028 }
_internal_add_step()9029 inline ::tensorflow::LabeledStepStats* LoggingResponse::_internal_add_step() {
9030   return _impl_.step_.Add();
9031 }
add_step()9032 inline ::tensorflow::LabeledStepStats* LoggingResponse::add_step() {
9033   ::tensorflow::LabeledStepStats* _add = _internal_add_step();
9034   // @@protoc_insertion_point(field_add:tensorflow.LoggingResponse.step)
9035   return _add;
9036 }
9037 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::LabeledStepStats >&
step()9038 LoggingResponse::step() const {
9039   // @@protoc_insertion_point(field_list:tensorflow.LoggingResponse.step)
9040   return _impl_.step_;
9041 }
9042 
9043 // -------------------------------------------------------------------
9044 
9045 // TraceOpts
9046 
9047 // double duration = 1;
clear_duration()9048 inline void TraceOpts::clear_duration() {
9049   _impl_.duration_ = 0;
9050 }
_internal_duration()9051 inline double TraceOpts::_internal_duration() const {
9052   return _impl_.duration_;
9053 }
duration()9054 inline double TraceOpts::duration() const {
9055   // @@protoc_insertion_point(field_get:tensorflow.TraceOpts.duration)
9056   return _internal_duration();
9057 }
_internal_set_duration(double value)9058 inline void TraceOpts::_internal_set_duration(double value) {
9059 
9060   _impl_.duration_ = value;
9061 }
set_duration(double value)9062 inline void TraceOpts::set_duration(double value) {
9063   _internal_set_duration(value);
9064   // @@protoc_insertion_point(field_set:tensorflow.TraceOpts.duration)
9065 }
9066 
9067 // bool use_step_profiler = 2;
clear_use_step_profiler()9068 inline void TraceOpts::clear_use_step_profiler() {
9069   _impl_.use_step_profiler_ = false;
9070 }
_internal_use_step_profiler()9071 inline bool TraceOpts::_internal_use_step_profiler() const {
9072   return _impl_.use_step_profiler_;
9073 }
use_step_profiler()9074 inline bool TraceOpts::use_step_profiler() const {
9075   // @@protoc_insertion_point(field_get:tensorflow.TraceOpts.use_step_profiler)
9076   return _internal_use_step_profiler();
9077 }
_internal_set_use_step_profiler(bool value)9078 inline void TraceOpts::_internal_set_use_step_profiler(bool value) {
9079 
9080   _impl_.use_step_profiler_ = value;
9081 }
set_use_step_profiler(bool value)9082 inline void TraceOpts::set_use_step_profiler(bool value) {
9083   _internal_set_use_step_profiler(value);
9084   // @@protoc_insertion_point(field_set:tensorflow.TraceOpts.use_step_profiler)
9085 }
9086 
9087 // bool use_kernel_profiler = 3;
clear_use_kernel_profiler()9088 inline void TraceOpts::clear_use_kernel_profiler() {
9089   _impl_.use_kernel_profiler_ = false;
9090 }
_internal_use_kernel_profiler()9091 inline bool TraceOpts::_internal_use_kernel_profiler() const {
9092   return _impl_.use_kernel_profiler_;
9093 }
use_kernel_profiler()9094 inline bool TraceOpts::use_kernel_profiler() const {
9095   // @@protoc_insertion_point(field_get:tensorflow.TraceOpts.use_kernel_profiler)
9096   return _internal_use_kernel_profiler();
9097 }
_internal_set_use_kernel_profiler(bool value)9098 inline void TraceOpts::_internal_set_use_kernel_profiler(bool value) {
9099 
9100   _impl_.use_kernel_profiler_ = value;
9101 }
set_use_kernel_profiler(bool value)9102 inline void TraceOpts::set_use_kernel_profiler(bool value) {
9103   _internal_set_use_kernel_profiler(value);
9104   // @@protoc_insertion_point(field_set:tensorflow.TraceOpts.use_kernel_profiler)
9105 }
9106 
9107 // bool use_extended_profiler = 4;
clear_use_extended_profiler()9108 inline void TraceOpts::clear_use_extended_profiler() {
9109   _impl_.use_extended_profiler_ = false;
9110 }
_internal_use_extended_profiler()9111 inline bool TraceOpts::_internal_use_extended_profiler() const {
9112   return _impl_.use_extended_profiler_;
9113 }
use_extended_profiler()9114 inline bool TraceOpts::use_extended_profiler() const {
9115   // @@protoc_insertion_point(field_get:tensorflow.TraceOpts.use_extended_profiler)
9116   return _internal_use_extended_profiler();
9117 }
_internal_set_use_extended_profiler(bool value)9118 inline void TraceOpts::_internal_set_use_extended_profiler(bool value) {
9119 
9120   _impl_.use_extended_profiler_ = value;
9121 }
set_use_extended_profiler(bool value)9122 inline void TraceOpts::set_use_extended_profiler(bool value) {
9123   _internal_set_use_extended_profiler(value);
9124   // @@protoc_insertion_point(field_set:tensorflow.TraceOpts.use_extended_profiler)
9125 }
9126 
9127 // bool use_gpu_profiler = 5;
clear_use_gpu_profiler()9128 inline void TraceOpts::clear_use_gpu_profiler() {
9129   _impl_.use_gpu_profiler_ = false;
9130 }
_internal_use_gpu_profiler()9131 inline bool TraceOpts::_internal_use_gpu_profiler() const {
9132   return _impl_.use_gpu_profiler_;
9133 }
use_gpu_profiler()9134 inline bool TraceOpts::use_gpu_profiler() const {
9135   // @@protoc_insertion_point(field_get:tensorflow.TraceOpts.use_gpu_profiler)
9136   return _internal_use_gpu_profiler();
9137 }
_internal_set_use_gpu_profiler(bool value)9138 inline void TraceOpts::_internal_set_use_gpu_profiler(bool value) {
9139 
9140   _impl_.use_gpu_profiler_ = value;
9141 }
set_use_gpu_profiler(bool value)9142 inline void TraceOpts::set_use_gpu_profiler(bool value) {
9143   _internal_set_use_gpu_profiler(value);
9144   // @@protoc_insertion_point(field_set:tensorflow.TraceOpts.use_gpu_profiler)
9145 }
9146 
9147 // bool use_sample_profiler = 6;
clear_use_sample_profiler()9148 inline void TraceOpts::clear_use_sample_profiler() {
9149   _impl_.use_sample_profiler_ = false;
9150 }
_internal_use_sample_profiler()9151 inline bool TraceOpts::_internal_use_sample_profiler() const {
9152   return _impl_.use_sample_profiler_;
9153 }
use_sample_profiler()9154 inline bool TraceOpts::use_sample_profiler() const {
9155   // @@protoc_insertion_point(field_get:tensorflow.TraceOpts.use_sample_profiler)
9156   return _internal_use_sample_profiler();
9157 }
_internal_set_use_sample_profiler(bool value)9158 inline void TraceOpts::_internal_set_use_sample_profiler(bool value) {
9159 
9160   _impl_.use_sample_profiler_ = value;
9161 }
set_use_sample_profiler(bool value)9162 inline void TraceOpts::set_use_sample_profiler(bool value) {
9163   _internal_set_use_sample_profiler(value);
9164   // @@protoc_insertion_point(field_set:tensorflow.TraceOpts.use_sample_profiler)
9165 }
9166 
9167 // -------------------------------------------------------------------
9168 
9169 // TracingRequest
9170 
9171 // .tensorflow.TraceOpts options = 1;
_internal_has_options()9172 inline bool TracingRequest::_internal_has_options() const {
9173   return this != internal_default_instance() && _impl_.options_ != nullptr;
9174 }
has_options()9175 inline bool TracingRequest::has_options() const {
9176   return _internal_has_options();
9177 }
clear_options()9178 inline void TracingRequest::clear_options() {
9179   if (GetArenaForAllocation() == nullptr && _impl_.options_ != nullptr) {
9180     delete _impl_.options_;
9181   }
9182   _impl_.options_ = nullptr;
9183 }
_internal_options()9184 inline const ::tensorflow::TraceOpts& TracingRequest::_internal_options() const {
9185   const ::tensorflow::TraceOpts* p = _impl_.options_;
9186   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TraceOpts&>(
9187       ::tensorflow::_TraceOpts_default_instance_);
9188 }
options()9189 inline const ::tensorflow::TraceOpts& TracingRequest::options() const {
9190   // @@protoc_insertion_point(field_get:tensorflow.TracingRequest.options)
9191   return _internal_options();
9192 }
unsafe_arena_set_allocated_options(::tensorflow::TraceOpts * options)9193 inline void TracingRequest::unsafe_arena_set_allocated_options(
9194     ::tensorflow::TraceOpts* options) {
9195   if (GetArenaForAllocation() == nullptr) {
9196     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
9197   }
9198   _impl_.options_ = options;
9199   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.TracingRequest.options)
9200 }
release_options()9201 inline ::tensorflow::TraceOpts* TracingRequest::release_options() {
9202 
9203   ::tensorflow::TraceOpts* temp = _impl_.options_;
9204   _impl_.options_ = nullptr;
9205 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
9206   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
9207   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9208   if (GetArenaForAllocation() == nullptr) { delete old; }
9209 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
9210   if (GetArenaForAllocation() != nullptr) {
9211     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9212   }
9213 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
9214   return temp;
9215 }
unsafe_arena_release_options()9216 inline ::tensorflow::TraceOpts* TracingRequest::unsafe_arena_release_options() {
9217   // @@protoc_insertion_point(field_release:tensorflow.TracingRequest.options)
9218 
9219   ::tensorflow::TraceOpts* temp = _impl_.options_;
9220   _impl_.options_ = nullptr;
9221   return temp;
9222 }
_internal_mutable_options()9223 inline ::tensorflow::TraceOpts* TracingRequest::_internal_mutable_options() {
9224 
9225   if (_impl_.options_ == nullptr) {
9226     auto* p = CreateMaybeMessage<::tensorflow::TraceOpts>(GetArenaForAllocation());
9227     _impl_.options_ = p;
9228   }
9229   return _impl_.options_;
9230 }
mutable_options()9231 inline ::tensorflow::TraceOpts* TracingRequest::mutable_options() {
9232   ::tensorflow::TraceOpts* _msg = _internal_mutable_options();
9233   // @@protoc_insertion_point(field_mutable:tensorflow.TracingRequest.options)
9234   return _msg;
9235 }
set_allocated_options(::tensorflow::TraceOpts * options)9236 inline void TracingRequest::set_allocated_options(::tensorflow::TraceOpts* options) {
9237   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
9238   if (message_arena == nullptr) {
9239     delete _impl_.options_;
9240   }
9241   if (options) {
9242     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
9243         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(options);
9244     if (message_arena != submessage_arena) {
9245       options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
9246           message_arena, options, submessage_arena);
9247     }
9248 
9249   } else {
9250 
9251   }
9252   _impl_.options_ = options;
9253   // @@protoc_insertion_point(field_set_allocated:tensorflow.TracingRequest.options)
9254 }
9255 
9256 // -------------------------------------------------------------------
9257 
9258 // TracingResponse
9259 
9260 // -------------------------------------------------------------------
9261 
9262 // RecvBufRequest
9263 
9264 // int64 step_id = 1;
clear_step_id()9265 inline void RecvBufRequest::clear_step_id() {
9266   _impl_.step_id_ = ::int64_t{0};
9267 }
_internal_step_id()9268 inline ::int64_t RecvBufRequest::_internal_step_id() const {
9269   return _impl_.step_id_;
9270 }
step_id()9271 inline ::int64_t RecvBufRequest::step_id() const {
9272   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.step_id)
9273   return _internal_step_id();
9274 }
_internal_set_step_id(::int64_t value)9275 inline void RecvBufRequest::_internal_set_step_id(::int64_t value) {
9276 
9277   _impl_.step_id_ = value;
9278 }
set_step_id(::int64_t value)9279 inline void RecvBufRequest::set_step_id(::int64_t value) {
9280   _internal_set_step_id(value);
9281   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.step_id)
9282 }
9283 
9284 // string buf_rendezvous_key = 2;
clear_buf_rendezvous_key()9285 inline void RecvBufRequest::clear_buf_rendezvous_key() {
9286   _impl_.buf_rendezvous_key_.ClearToEmpty();
9287 }
buf_rendezvous_key()9288 inline const std::string& RecvBufRequest::buf_rendezvous_key() const {
9289   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.buf_rendezvous_key)
9290   return _internal_buf_rendezvous_key();
9291 }
9292 template <typename ArgT0, typename... ArgT>
9293 inline PROTOBUF_ALWAYS_INLINE
set_buf_rendezvous_key(ArgT0 && arg0,ArgT...args)9294 void RecvBufRequest::set_buf_rendezvous_key(ArgT0&& arg0, ArgT... args) {
9295 
9296  _impl_.buf_rendezvous_key_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
9297   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.buf_rendezvous_key)
9298 }
mutable_buf_rendezvous_key()9299 inline std::string* RecvBufRequest::mutable_buf_rendezvous_key() {
9300   std::string* _s = _internal_mutable_buf_rendezvous_key();
9301   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufRequest.buf_rendezvous_key)
9302   return _s;
9303 }
_internal_buf_rendezvous_key()9304 inline const std::string& RecvBufRequest::_internal_buf_rendezvous_key() const {
9305   return _impl_.buf_rendezvous_key_.Get();
9306 }
_internal_set_buf_rendezvous_key(const std::string & value)9307 inline void RecvBufRequest::_internal_set_buf_rendezvous_key(const std::string& value) {
9308 
9309   _impl_.buf_rendezvous_key_.Set(value, GetArenaForAllocation());
9310 }
_internal_mutable_buf_rendezvous_key()9311 inline std::string* RecvBufRequest::_internal_mutable_buf_rendezvous_key() {
9312 
9313   return _impl_.buf_rendezvous_key_.Mutable(GetArenaForAllocation());
9314 }
release_buf_rendezvous_key()9315 inline std::string* RecvBufRequest::release_buf_rendezvous_key() {
9316   // @@protoc_insertion_point(field_release:tensorflow.RecvBufRequest.buf_rendezvous_key)
9317   return _impl_.buf_rendezvous_key_.Release();
9318 }
set_allocated_buf_rendezvous_key(std::string * buf_rendezvous_key)9319 inline void RecvBufRequest::set_allocated_buf_rendezvous_key(std::string* buf_rendezvous_key) {
9320   _impl_.buf_rendezvous_key_.SetAllocated(buf_rendezvous_key, GetArenaForAllocation());
9321 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9322   if (_impl_.buf_rendezvous_key_.IsDefault()) {
9323     _impl_.buf_rendezvous_key_.Set("", GetArenaForAllocation());
9324   }
9325 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9326   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufRequest.buf_rendezvous_key)
9327 }
9328 
9329 // int64 num_bytes = 3;
clear_num_bytes()9330 inline void RecvBufRequest::clear_num_bytes() {
9331   _impl_.num_bytes_ = ::int64_t{0};
9332 }
_internal_num_bytes()9333 inline ::int64_t RecvBufRequest::_internal_num_bytes() const {
9334   return _impl_.num_bytes_;
9335 }
num_bytes()9336 inline ::int64_t RecvBufRequest::num_bytes() const {
9337   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.num_bytes)
9338   return _internal_num_bytes();
9339 }
_internal_set_num_bytes(::int64_t value)9340 inline void RecvBufRequest::_internal_set_num_bytes(::int64_t value) {
9341 
9342   _impl_.num_bytes_ = value;
9343 }
set_num_bytes(::int64_t value)9344 inline void RecvBufRequest::set_num_bytes(::int64_t value) {
9345   _internal_set_num_bytes(value);
9346   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.num_bytes)
9347 }
9348 
9349 // fixed64 buf_ptr = 4;
clear_buf_ptr()9350 inline void RecvBufRequest::clear_buf_ptr() {
9351   _impl_.buf_ptr_ = ::uint64_t{0u};
9352 }
_internal_buf_ptr()9353 inline ::uint64_t RecvBufRequest::_internal_buf_ptr() const {
9354   return _impl_.buf_ptr_;
9355 }
buf_ptr()9356 inline ::uint64_t RecvBufRequest::buf_ptr() const {
9357   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.buf_ptr)
9358   return _internal_buf_ptr();
9359 }
_internal_set_buf_ptr(::uint64_t value)9360 inline void RecvBufRequest::_internal_set_buf_ptr(::uint64_t value) {
9361 
9362   _impl_.buf_ptr_ = value;
9363 }
set_buf_ptr(::uint64_t value)9364 inline void RecvBufRequest::set_buf_ptr(::uint64_t value) {
9365   _internal_set_buf_ptr(value);
9366   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.buf_ptr)
9367 }
9368 
9369 // .tensorflow.DeviceLocality client_locality = 5;
_internal_has_client_locality()9370 inline bool RecvBufRequest::_internal_has_client_locality() const {
9371   return this != internal_default_instance() && _impl_.client_locality_ != nullptr;
9372 }
has_client_locality()9373 inline bool RecvBufRequest::has_client_locality() const {
9374   return _internal_has_client_locality();
9375 }
_internal_client_locality()9376 inline const ::tensorflow::DeviceLocality& RecvBufRequest::_internal_client_locality() const {
9377   const ::tensorflow::DeviceLocality* p = _impl_.client_locality_;
9378   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceLocality&>(
9379       ::tensorflow::_DeviceLocality_default_instance_);
9380 }
client_locality()9381 inline const ::tensorflow::DeviceLocality& RecvBufRequest::client_locality() const {
9382   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.client_locality)
9383   return _internal_client_locality();
9384 }
unsafe_arena_set_allocated_client_locality(::tensorflow::DeviceLocality * client_locality)9385 inline void RecvBufRequest::unsafe_arena_set_allocated_client_locality(
9386     ::tensorflow::DeviceLocality* client_locality) {
9387   if (GetArenaForAllocation() == nullptr) {
9388     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_locality_);
9389   }
9390   _impl_.client_locality_ = client_locality;
9391   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvBufRequest.client_locality)
9392 }
release_client_locality()9393 inline ::tensorflow::DeviceLocality* RecvBufRequest::release_client_locality() {
9394 
9395   ::tensorflow::DeviceLocality* temp = _impl_.client_locality_;
9396   _impl_.client_locality_ = nullptr;
9397 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
9398   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
9399   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9400   if (GetArenaForAllocation() == nullptr) { delete old; }
9401 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
9402   if (GetArenaForAllocation() != nullptr) {
9403     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9404   }
9405 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
9406   return temp;
9407 }
unsafe_arena_release_client_locality()9408 inline ::tensorflow::DeviceLocality* RecvBufRequest::unsafe_arena_release_client_locality() {
9409   // @@protoc_insertion_point(field_release:tensorflow.RecvBufRequest.client_locality)
9410 
9411   ::tensorflow::DeviceLocality* temp = _impl_.client_locality_;
9412   _impl_.client_locality_ = nullptr;
9413   return temp;
9414 }
_internal_mutable_client_locality()9415 inline ::tensorflow::DeviceLocality* RecvBufRequest::_internal_mutable_client_locality() {
9416 
9417   if (_impl_.client_locality_ == nullptr) {
9418     auto* p = CreateMaybeMessage<::tensorflow::DeviceLocality>(GetArenaForAllocation());
9419     _impl_.client_locality_ = p;
9420   }
9421   return _impl_.client_locality_;
9422 }
mutable_client_locality()9423 inline ::tensorflow::DeviceLocality* RecvBufRequest::mutable_client_locality() {
9424   ::tensorflow::DeviceLocality* _msg = _internal_mutable_client_locality();
9425   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufRequest.client_locality)
9426   return _msg;
9427 }
set_allocated_client_locality(::tensorflow::DeviceLocality * client_locality)9428 inline void RecvBufRequest::set_allocated_client_locality(::tensorflow::DeviceLocality* client_locality) {
9429   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
9430   if (message_arena == nullptr) {
9431     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.client_locality_);
9432   }
9433   if (client_locality) {
9434     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
9435         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
9436                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_locality));
9437     if (message_arena != submessage_arena) {
9438       client_locality = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
9439           message_arena, client_locality, submessage_arena);
9440     }
9441 
9442   } else {
9443 
9444   }
9445   _impl_.client_locality_ = client_locality;
9446   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufRequest.client_locality)
9447 }
9448 
9449 // .tensorflow.DeviceLocality server_locality = 6;
_internal_has_server_locality()9450 inline bool RecvBufRequest::_internal_has_server_locality() const {
9451   return this != internal_default_instance() && _impl_.server_locality_ != nullptr;
9452 }
has_server_locality()9453 inline bool RecvBufRequest::has_server_locality() const {
9454   return _internal_has_server_locality();
9455 }
_internal_server_locality()9456 inline const ::tensorflow::DeviceLocality& RecvBufRequest::_internal_server_locality() const {
9457   const ::tensorflow::DeviceLocality* p = _impl_.server_locality_;
9458   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceLocality&>(
9459       ::tensorflow::_DeviceLocality_default_instance_);
9460 }
server_locality()9461 inline const ::tensorflow::DeviceLocality& RecvBufRequest::server_locality() const {
9462   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.server_locality)
9463   return _internal_server_locality();
9464 }
unsafe_arena_set_allocated_server_locality(::tensorflow::DeviceLocality * server_locality)9465 inline void RecvBufRequest::unsafe_arena_set_allocated_server_locality(
9466     ::tensorflow::DeviceLocality* server_locality) {
9467   if (GetArenaForAllocation() == nullptr) {
9468     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_locality_);
9469   }
9470   _impl_.server_locality_ = server_locality;
9471   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvBufRequest.server_locality)
9472 }
release_server_locality()9473 inline ::tensorflow::DeviceLocality* RecvBufRequest::release_server_locality() {
9474 
9475   ::tensorflow::DeviceLocality* temp = _impl_.server_locality_;
9476   _impl_.server_locality_ = nullptr;
9477 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
9478   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
9479   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9480   if (GetArenaForAllocation() == nullptr) { delete old; }
9481 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
9482   if (GetArenaForAllocation() != nullptr) {
9483     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9484   }
9485 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
9486   return temp;
9487 }
unsafe_arena_release_server_locality()9488 inline ::tensorflow::DeviceLocality* RecvBufRequest::unsafe_arena_release_server_locality() {
9489   // @@protoc_insertion_point(field_release:tensorflow.RecvBufRequest.server_locality)
9490 
9491   ::tensorflow::DeviceLocality* temp = _impl_.server_locality_;
9492   _impl_.server_locality_ = nullptr;
9493   return temp;
9494 }
_internal_mutable_server_locality()9495 inline ::tensorflow::DeviceLocality* RecvBufRequest::_internal_mutable_server_locality() {
9496 
9497   if (_impl_.server_locality_ == nullptr) {
9498     auto* p = CreateMaybeMessage<::tensorflow::DeviceLocality>(GetArenaForAllocation());
9499     _impl_.server_locality_ = p;
9500   }
9501   return _impl_.server_locality_;
9502 }
mutable_server_locality()9503 inline ::tensorflow::DeviceLocality* RecvBufRequest::mutable_server_locality() {
9504   ::tensorflow::DeviceLocality* _msg = _internal_mutable_server_locality();
9505   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufRequest.server_locality)
9506   return _msg;
9507 }
set_allocated_server_locality(::tensorflow::DeviceLocality * server_locality)9508 inline void RecvBufRequest::set_allocated_server_locality(::tensorflow::DeviceLocality* server_locality) {
9509   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
9510   if (message_arena == nullptr) {
9511     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.server_locality_);
9512   }
9513   if (server_locality) {
9514     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
9515         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
9516                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(server_locality));
9517     if (message_arena != submessage_arena) {
9518       server_locality = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
9519           message_arena, server_locality, submessage_arena);
9520     }
9521 
9522   } else {
9523 
9524   }
9525   _impl_.server_locality_ = server_locality;
9526   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufRequest.server_locality)
9527 }
9528 
9529 // .google.protobuf.Any transport_options = 7;
_internal_has_transport_options()9530 inline bool RecvBufRequest::_internal_has_transport_options() const {
9531   return this != internal_default_instance() && _impl_.transport_options_ != nullptr;
9532 }
has_transport_options()9533 inline bool RecvBufRequest::has_transport_options() const {
9534   return _internal_has_transport_options();
9535 }
_internal_transport_options()9536 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvBufRequest::_internal_transport_options() const {
9537   const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.transport_options_;
9538   return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
9539       ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
9540 }
transport_options()9541 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvBufRequest::transport_options() const {
9542   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.transport_options)
9543   return _internal_transport_options();
9544 }
unsafe_arena_set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)9545 inline void RecvBufRequest::unsafe_arena_set_allocated_transport_options(
9546     ::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
9547   if (GetArenaForAllocation() == nullptr) {
9548     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
9549   }
9550   _impl_.transport_options_ = transport_options;
9551   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvBufRequest.transport_options)
9552 }
release_transport_options()9553 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufRequest::release_transport_options() {
9554 
9555   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
9556   _impl_.transport_options_ = nullptr;
9557 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
9558   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
9559   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9560   if (GetArenaForAllocation() == nullptr) { delete old; }
9561 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
9562   if (GetArenaForAllocation() != nullptr) {
9563     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9564   }
9565 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
9566   return temp;
9567 }
unsafe_arena_release_transport_options()9568 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufRequest::unsafe_arena_release_transport_options() {
9569   // @@protoc_insertion_point(field_release:tensorflow.RecvBufRequest.transport_options)
9570 
9571   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
9572   _impl_.transport_options_ = nullptr;
9573   return temp;
9574 }
_internal_mutable_transport_options()9575 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufRequest::_internal_mutable_transport_options() {
9576 
9577   if (_impl_.transport_options_ == nullptr) {
9578     auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
9579     _impl_.transport_options_ = p;
9580   }
9581   return _impl_.transport_options_;
9582 }
mutable_transport_options()9583 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufRequest::mutable_transport_options() {
9584   ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_transport_options();
9585   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufRequest.transport_options)
9586   return _msg;
9587 }
set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)9588 inline void RecvBufRequest::set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
9589   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
9590   if (message_arena == nullptr) {
9591     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
9592   }
9593   if (transport_options) {
9594     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
9595         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
9596                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transport_options));
9597     if (message_arena != submessage_arena) {
9598       transport_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
9599           message_arena, transport_options, submessage_arena);
9600     }
9601 
9602   } else {
9603 
9604   }
9605   _impl_.transport_options_ = transport_options;
9606   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufRequest.transport_options)
9607 }
9608 
9609 // string src_device = 8;
clear_src_device()9610 inline void RecvBufRequest::clear_src_device() {
9611   _impl_.src_device_.ClearToEmpty();
9612 }
src_device()9613 inline const std::string& RecvBufRequest::src_device() const {
9614   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.src_device)
9615   return _internal_src_device();
9616 }
9617 template <typename ArgT0, typename... ArgT>
9618 inline PROTOBUF_ALWAYS_INLINE
set_src_device(ArgT0 && arg0,ArgT...args)9619 void RecvBufRequest::set_src_device(ArgT0&& arg0, ArgT... args) {
9620 
9621  _impl_.src_device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
9622   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.src_device)
9623 }
mutable_src_device()9624 inline std::string* RecvBufRequest::mutable_src_device() {
9625   std::string* _s = _internal_mutable_src_device();
9626   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufRequest.src_device)
9627   return _s;
9628 }
_internal_src_device()9629 inline const std::string& RecvBufRequest::_internal_src_device() const {
9630   return _impl_.src_device_.Get();
9631 }
_internal_set_src_device(const std::string & value)9632 inline void RecvBufRequest::_internal_set_src_device(const std::string& value) {
9633 
9634   _impl_.src_device_.Set(value, GetArenaForAllocation());
9635 }
_internal_mutable_src_device()9636 inline std::string* RecvBufRequest::_internal_mutable_src_device() {
9637 
9638   return _impl_.src_device_.Mutable(GetArenaForAllocation());
9639 }
release_src_device()9640 inline std::string* RecvBufRequest::release_src_device() {
9641   // @@protoc_insertion_point(field_release:tensorflow.RecvBufRequest.src_device)
9642   return _impl_.src_device_.Release();
9643 }
set_allocated_src_device(std::string * src_device)9644 inline void RecvBufRequest::set_allocated_src_device(std::string* src_device) {
9645   _impl_.src_device_.SetAllocated(src_device, GetArenaForAllocation());
9646 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9647   if (_impl_.src_device_.IsDefault()) {
9648     _impl_.src_device_.Set("", GetArenaForAllocation());
9649   }
9650 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9651   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufRequest.src_device)
9652 }
9653 
9654 // string dst_device = 9;
clear_dst_device()9655 inline void RecvBufRequest::clear_dst_device() {
9656   _impl_.dst_device_.ClearToEmpty();
9657 }
dst_device()9658 inline const std::string& RecvBufRequest::dst_device() const {
9659   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.dst_device)
9660   return _internal_dst_device();
9661 }
9662 template <typename ArgT0, typename... ArgT>
9663 inline PROTOBUF_ALWAYS_INLINE
set_dst_device(ArgT0 && arg0,ArgT...args)9664 void RecvBufRequest::set_dst_device(ArgT0&& arg0, ArgT... args) {
9665 
9666  _impl_.dst_device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
9667   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.dst_device)
9668 }
mutable_dst_device()9669 inline std::string* RecvBufRequest::mutable_dst_device() {
9670   std::string* _s = _internal_mutable_dst_device();
9671   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufRequest.dst_device)
9672   return _s;
9673 }
_internal_dst_device()9674 inline const std::string& RecvBufRequest::_internal_dst_device() const {
9675   return _impl_.dst_device_.Get();
9676 }
_internal_set_dst_device(const std::string & value)9677 inline void RecvBufRequest::_internal_set_dst_device(const std::string& value) {
9678 
9679   _impl_.dst_device_.Set(value, GetArenaForAllocation());
9680 }
_internal_mutable_dst_device()9681 inline std::string* RecvBufRequest::_internal_mutable_dst_device() {
9682 
9683   return _impl_.dst_device_.Mutable(GetArenaForAllocation());
9684 }
release_dst_device()9685 inline std::string* RecvBufRequest::release_dst_device() {
9686   // @@protoc_insertion_point(field_release:tensorflow.RecvBufRequest.dst_device)
9687   return _impl_.dst_device_.Release();
9688 }
set_allocated_dst_device(std::string * dst_device)9689 inline void RecvBufRequest::set_allocated_dst_device(std::string* dst_device) {
9690   _impl_.dst_device_.SetAllocated(dst_device, GetArenaForAllocation());
9691 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
9692   if (_impl_.dst_device_.IsDefault()) {
9693     _impl_.dst_device_.Set("", GetArenaForAllocation());
9694   }
9695 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
9696   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufRequest.dst_device)
9697 }
9698 
9699 // int64 request_id = 10;
clear_request_id()9700 inline void RecvBufRequest::clear_request_id() {
9701   _impl_.request_id_ = ::int64_t{0};
9702 }
_internal_request_id()9703 inline ::int64_t RecvBufRequest::_internal_request_id() const {
9704   return _impl_.request_id_;
9705 }
request_id()9706 inline ::int64_t RecvBufRequest::request_id() const {
9707   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.request_id)
9708   return _internal_request_id();
9709 }
_internal_set_request_id(::int64_t value)9710 inline void RecvBufRequest::_internal_set_request_id(::int64_t value) {
9711 
9712   _impl_.request_id_ = value;
9713 }
set_request_id(::int64_t value)9714 inline void RecvBufRequest::set_request_id(::int64_t value) {
9715   _internal_set_request_id(value);
9716   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.request_id)
9717 }
9718 
9719 // uint64 src_incarnation = 11;
clear_src_incarnation()9720 inline void RecvBufRequest::clear_src_incarnation() {
9721   _impl_.src_incarnation_ = ::uint64_t{0u};
9722 }
_internal_src_incarnation()9723 inline ::uint64_t RecvBufRequest::_internal_src_incarnation() const {
9724   return _impl_.src_incarnation_;
9725 }
src_incarnation()9726 inline ::uint64_t RecvBufRequest::src_incarnation() const {
9727   // @@protoc_insertion_point(field_get:tensorflow.RecvBufRequest.src_incarnation)
9728   return _internal_src_incarnation();
9729 }
_internal_set_src_incarnation(::uint64_t value)9730 inline void RecvBufRequest::_internal_set_src_incarnation(::uint64_t value) {
9731 
9732   _impl_.src_incarnation_ = value;
9733 }
set_src_incarnation(::uint64_t value)9734 inline void RecvBufRequest::set_src_incarnation(::uint64_t value) {
9735   _internal_set_src_incarnation(value);
9736   // @@protoc_insertion_point(field_set:tensorflow.RecvBufRequest.src_incarnation)
9737 }
9738 
9739 // -------------------------------------------------------------------
9740 
9741 // RecvBufResponse
9742 
9743 // fixed64 buf_ptr = 1;
clear_buf_ptr()9744 inline void RecvBufResponse::clear_buf_ptr() {
9745   _impl_.buf_ptr_ = ::uint64_t{0u};
9746 }
_internal_buf_ptr()9747 inline ::uint64_t RecvBufResponse::_internal_buf_ptr() const {
9748   return _impl_.buf_ptr_;
9749 }
buf_ptr()9750 inline ::uint64_t RecvBufResponse::buf_ptr() const {
9751   // @@protoc_insertion_point(field_get:tensorflow.RecvBufResponse.buf_ptr)
9752   return _internal_buf_ptr();
9753 }
_internal_set_buf_ptr(::uint64_t value)9754 inline void RecvBufResponse::_internal_set_buf_ptr(::uint64_t value) {
9755 
9756   _impl_.buf_ptr_ = value;
9757 }
set_buf_ptr(::uint64_t value)9758 inline void RecvBufResponse::set_buf_ptr(::uint64_t value) {
9759   _internal_set_buf_ptr(value);
9760   // @@protoc_insertion_point(field_set:tensorflow.RecvBufResponse.buf_ptr)
9761 }
9762 
9763 // int64 num_bytes = 2;
clear_num_bytes()9764 inline void RecvBufResponse::clear_num_bytes() {
9765   _impl_.num_bytes_ = ::int64_t{0};
9766 }
_internal_num_bytes()9767 inline ::int64_t RecvBufResponse::_internal_num_bytes() const {
9768   return _impl_.num_bytes_;
9769 }
num_bytes()9770 inline ::int64_t RecvBufResponse::num_bytes() const {
9771   // @@protoc_insertion_point(field_get:tensorflow.RecvBufResponse.num_bytes)
9772   return _internal_num_bytes();
9773 }
_internal_set_num_bytes(::int64_t value)9774 inline void RecvBufResponse::_internal_set_num_bytes(::int64_t value) {
9775 
9776   _impl_.num_bytes_ = value;
9777 }
set_num_bytes(::int64_t value)9778 inline void RecvBufResponse::set_num_bytes(::int64_t value) {
9779   _internal_set_num_bytes(value);
9780   // @@protoc_insertion_point(field_set:tensorflow.RecvBufResponse.num_bytes)
9781 }
9782 
9783 // bool is_dead = 3;
clear_is_dead()9784 inline void RecvBufResponse::clear_is_dead() {
9785   _impl_.is_dead_ = false;
9786 }
_internal_is_dead()9787 inline bool RecvBufResponse::_internal_is_dead() const {
9788   return _impl_.is_dead_;
9789 }
is_dead()9790 inline bool RecvBufResponse::is_dead() const {
9791   // @@protoc_insertion_point(field_get:tensorflow.RecvBufResponse.is_dead)
9792   return _internal_is_dead();
9793 }
_internal_set_is_dead(bool value)9794 inline void RecvBufResponse::_internal_set_is_dead(bool value) {
9795 
9796   _impl_.is_dead_ = value;
9797 }
set_is_dead(bool value)9798 inline void RecvBufResponse::set_is_dead(bool value) {
9799   _internal_set_is_dead(value);
9800   // @@protoc_insertion_point(field_set:tensorflow.RecvBufResponse.is_dead)
9801 }
9802 
9803 // .google.protobuf.Any transport_options = 4;
_internal_has_transport_options()9804 inline bool RecvBufResponse::_internal_has_transport_options() const {
9805   return this != internal_default_instance() && _impl_.transport_options_ != nullptr;
9806 }
has_transport_options()9807 inline bool RecvBufResponse::has_transport_options() const {
9808   return _internal_has_transport_options();
9809 }
_internal_transport_options()9810 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvBufResponse::_internal_transport_options() const {
9811   const ::PROTOBUF_NAMESPACE_ID::Any* p = _impl_.transport_options_;
9812   return p != nullptr ? *p : reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Any&>(
9813       ::PROTOBUF_NAMESPACE_ID::_Any_default_instance_);
9814 }
transport_options()9815 inline const ::PROTOBUF_NAMESPACE_ID::Any& RecvBufResponse::transport_options() const {
9816   // @@protoc_insertion_point(field_get:tensorflow.RecvBufResponse.transport_options)
9817   return _internal_transport_options();
9818 }
unsafe_arena_set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)9819 inline void RecvBufResponse::unsafe_arena_set_allocated_transport_options(
9820     ::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
9821   if (GetArenaForAllocation() == nullptr) {
9822     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
9823   }
9824   _impl_.transport_options_ = transport_options;
9825   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RecvBufResponse.transport_options)
9826 }
release_transport_options()9827 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufResponse::release_transport_options() {
9828 
9829   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
9830   _impl_.transport_options_ = nullptr;
9831 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
9832   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
9833   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9834   if (GetArenaForAllocation() == nullptr) { delete old; }
9835 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
9836   if (GetArenaForAllocation() != nullptr) {
9837     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
9838   }
9839 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
9840   return temp;
9841 }
unsafe_arena_release_transport_options()9842 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufResponse::unsafe_arena_release_transport_options() {
9843   // @@protoc_insertion_point(field_release:tensorflow.RecvBufResponse.transport_options)
9844 
9845   ::PROTOBUF_NAMESPACE_ID::Any* temp = _impl_.transport_options_;
9846   _impl_.transport_options_ = nullptr;
9847   return temp;
9848 }
_internal_mutable_transport_options()9849 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufResponse::_internal_mutable_transport_options() {
9850 
9851   if (_impl_.transport_options_ == nullptr) {
9852     auto* p = CreateMaybeMessage<::PROTOBUF_NAMESPACE_ID::Any>(GetArenaForAllocation());
9853     _impl_.transport_options_ = p;
9854   }
9855   return _impl_.transport_options_;
9856 }
mutable_transport_options()9857 inline ::PROTOBUF_NAMESPACE_ID::Any* RecvBufResponse::mutable_transport_options() {
9858   ::PROTOBUF_NAMESPACE_ID::Any* _msg = _internal_mutable_transport_options();
9859   // @@protoc_insertion_point(field_mutable:tensorflow.RecvBufResponse.transport_options)
9860   return _msg;
9861 }
set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any * transport_options)9862 inline void RecvBufResponse::set_allocated_transport_options(::PROTOBUF_NAMESPACE_ID::Any* transport_options) {
9863   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
9864   if (message_arena == nullptr) {
9865     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.transport_options_);
9866   }
9867   if (transport_options) {
9868     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
9869         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
9870                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(transport_options));
9871     if (message_arena != submessage_arena) {
9872       transport_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
9873           message_arena, transport_options, submessage_arena);
9874     }
9875 
9876   } else {
9877 
9878   }
9879   _impl_.transport_options_ = transport_options;
9880   // @@protoc_insertion_point(field_set_allocated:tensorflow.RecvBufResponse.transport_options)
9881 }
9882 
9883 // int64 send_start_micros = 5;
clear_send_start_micros()9884 inline void RecvBufResponse::clear_send_start_micros() {
9885   _impl_.send_start_micros_ = ::int64_t{0};
9886 }
_internal_send_start_micros()9887 inline ::int64_t RecvBufResponse::_internal_send_start_micros() const {
9888   return _impl_.send_start_micros_;
9889 }
send_start_micros()9890 inline ::int64_t RecvBufResponse::send_start_micros() const {
9891   // @@protoc_insertion_point(field_get:tensorflow.RecvBufResponse.send_start_micros)
9892   return _internal_send_start_micros();
9893 }
_internal_set_send_start_micros(::int64_t value)9894 inline void RecvBufResponse::_internal_set_send_start_micros(::int64_t value) {
9895 
9896   _impl_.send_start_micros_ = value;
9897 }
set_send_start_micros(::int64_t value)9898 inline void RecvBufResponse::set_send_start_micros(::int64_t value) {
9899   _internal_set_send_start_micros(value);
9900   // @@protoc_insertion_point(field_set:tensorflow.RecvBufResponse.send_start_micros)
9901 }
9902 
9903 // bool require_ack = 6;
clear_require_ack()9904 inline void RecvBufResponse::clear_require_ack() {
9905   _impl_.require_ack_ = false;
9906 }
_internal_require_ack()9907 inline bool RecvBufResponse::_internal_require_ack() const {
9908   return _impl_.require_ack_;
9909 }
require_ack()9910 inline bool RecvBufResponse::require_ack() const {
9911   // @@protoc_insertion_point(field_get:tensorflow.RecvBufResponse.require_ack)
9912   return _internal_require_ack();
9913 }
_internal_set_require_ack(bool value)9914 inline void RecvBufResponse::_internal_set_require_ack(bool value) {
9915 
9916   _impl_.require_ack_ = value;
9917 }
set_require_ack(bool value)9918 inline void RecvBufResponse::set_require_ack(bool value) {
9919   _internal_set_require_ack(value);
9920   // @@protoc_insertion_point(field_set:tensorflow.RecvBufResponse.require_ack)
9921 }
9922 
9923 // -------------------------------------------------------------------
9924 
9925 // CompleteGroupRequest
9926 
9927 // int32 group_key = 1;
clear_group_key()9928 inline void CompleteGroupRequest::clear_group_key() {
9929   _impl_.group_key_ = 0;
9930 }
_internal_group_key()9931 inline ::int32_t CompleteGroupRequest::_internal_group_key() const {
9932   return _impl_.group_key_;
9933 }
group_key()9934 inline ::int32_t CompleteGroupRequest::group_key() const {
9935   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupRequest.group_key)
9936   return _internal_group_key();
9937 }
_internal_set_group_key(::int32_t value)9938 inline void CompleteGroupRequest::_internal_set_group_key(::int32_t value) {
9939 
9940   _impl_.group_key_ = value;
9941 }
set_group_key(::int32_t value)9942 inline void CompleteGroupRequest::set_group_key(::int32_t value) {
9943   _internal_set_group_key(value);
9944   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupRequest.group_key)
9945 }
9946 
9947 // int32 group_size = 2;
clear_group_size()9948 inline void CompleteGroupRequest::clear_group_size() {
9949   _impl_.group_size_ = 0;
9950 }
_internal_group_size()9951 inline ::int32_t CompleteGroupRequest::_internal_group_size() const {
9952   return _impl_.group_size_;
9953 }
group_size()9954 inline ::int32_t CompleteGroupRequest::group_size() const {
9955   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupRequest.group_size)
9956   return _internal_group_size();
9957 }
_internal_set_group_size(::int32_t value)9958 inline void CompleteGroupRequest::_internal_set_group_size(::int32_t value) {
9959 
9960   _impl_.group_size_ = value;
9961 }
set_group_size(::int32_t value)9962 inline void CompleteGroupRequest::set_group_size(::int32_t value) {
9963   _internal_set_group_size(value);
9964   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupRequest.group_size)
9965 }
9966 
9967 // string device_type = 3;
clear_device_type()9968 inline void CompleteGroupRequest::clear_device_type() {
9969   _impl_.device_type_.ClearToEmpty();
9970 }
device_type()9971 inline const std::string& CompleteGroupRequest::device_type() const {
9972   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupRequest.device_type)
9973   return _internal_device_type();
9974 }
9975 template <typename ArgT0, typename... ArgT>
9976 inline PROTOBUF_ALWAYS_INLINE
set_device_type(ArgT0 && arg0,ArgT...args)9977 void CompleteGroupRequest::set_device_type(ArgT0&& arg0, ArgT... args) {
9978 
9979  _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
9980   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupRequest.device_type)
9981 }
mutable_device_type()9982 inline std::string* CompleteGroupRequest::mutable_device_type() {
9983   std::string* _s = _internal_mutable_device_type();
9984   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteGroupRequest.device_type)
9985   return _s;
9986 }
_internal_device_type()9987 inline const std::string& CompleteGroupRequest::_internal_device_type() const {
9988   return _impl_.device_type_.Get();
9989 }
_internal_set_device_type(const std::string & value)9990 inline void CompleteGroupRequest::_internal_set_device_type(const std::string& value) {
9991 
9992   _impl_.device_type_.Set(value, GetArenaForAllocation());
9993 }
_internal_mutable_device_type()9994 inline std::string* CompleteGroupRequest::_internal_mutable_device_type() {
9995 
9996   return _impl_.device_type_.Mutable(GetArenaForAllocation());
9997 }
release_device_type()9998 inline std::string* CompleteGroupRequest::release_device_type() {
9999   // @@protoc_insertion_point(field_release:tensorflow.CompleteGroupRequest.device_type)
10000   return _impl_.device_type_.Release();
10001 }
set_allocated_device_type(std::string * device_type)10002 inline void CompleteGroupRequest::set_allocated_device_type(std::string* device_type) {
10003   _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
10004 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10005   if (_impl_.device_type_.IsDefault()) {
10006     _impl_.device_type_.Set("", GetArenaForAllocation());
10007   }
10008 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10009   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteGroupRequest.device_type)
10010 }
10011 
10012 // int32 collective_type = 5;
clear_collective_type()10013 inline void CompleteGroupRequest::clear_collective_type() {
10014   _impl_.collective_type_ = 0;
10015 }
_internal_collective_type()10016 inline ::int32_t CompleteGroupRequest::_internal_collective_type() const {
10017   return _impl_.collective_type_;
10018 }
collective_type()10019 inline ::int32_t CompleteGroupRequest::collective_type() const {
10020   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupRequest.collective_type)
10021   return _internal_collective_type();
10022 }
_internal_set_collective_type(::int32_t value)10023 inline void CompleteGroupRequest::_internal_set_collective_type(::int32_t value) {
10024 
10025   _impl_.collective_type_ = value;
10026 }
set_collective_type(::int32_t value)10027 inline void CompleteGroupRequest::set_collective_type(::int32_t value) {
10028   _internal_set_collective_type(value);
10029   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupRequest.collective_type)
10030 }
10031 
10032 // .tensorflow.DeviceAttributes device_attributes = 6;
_internal_has_device_attributes()10033 inline bool CompleteGroupRequest::_internal_has_device_attributes() const {
10034   return this != internal_default_instance() && _impl_.device_attributes_ != nullptr;
10035 }
has_device_attributes()10036 inline bool CompleteGroupRequest::has_device_attributes() const {
10037   return _internal_has_device_attributes();
10038 }
_internal_device_attributes()10039 inline const ::tensorflow::DeviceAttributes& CompleteGroupRequest::_internal_device_attributes() const {
10040   const ::tensorflow::DeviceAttributes* p = _impl_.device_attributes_;
10041   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::DeviceAttributes&>(
10042       ::tensorflow::_DeviceAttributes_default_instance_);
10043 }
device_attributes()10044 inline const ::tensorflow::DeviceAttributes& CompleteGroupRequest::device_attributes() const {
10045   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupRequest.device_attributes)
10046   return _internal_device_attributes();
10047 }
unsafe_arena_set_allocated_device_attributes(::tensorflow::DeviceAttributes * device_attributes)10048 inline void CompleteGroupRequest::unsafe_arena_set_allocated_device_attributes(
10049     ::tensorflow::DeviceAttributes* device_attributes) {
10050   if (GetArenaForAllocation() == nullptr) {
10051     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_attributes_);
10052   }
10053   _impl_.device_attributes_ = device_attributes;
10054   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CompleteGroupRequest.device_attributes)
10055 }
release_device_attributes()10056 inline ::tensorflow::DeviceAttributes* CompleteGroupRequest::release_device_attributes() {
10057 
10058   ::tensorflow::DeviceAttributes* temp = _impl_.device_attributes_;
10059   _impl_.device_attributes_ = nullptr;
10060 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
10061   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
10062   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
10063   if (GetArenaForAllocation() == nullptr) { delete old; }
10064 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
10065   if (GetArenaForAllocation() != nullptr) {
10066     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
10067   }
10068 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
10069   return temp;
10070 }
unsafe_arena_release_device_attributes()10071 inline ::tensorflow::DeviceAttributes* CompleteGroupRequest::unsafe_arena_release_device_attributes() {
10072   // @@protoc_insertion_point(field_release:tensorflow.CompleteGroupRequest.device_attributes)
10073 
10074   ::tensorflow::DeviceAttributes* temp = _impl_.device_attributes_;
10075   _impl_.device_attributes_ = nullptr;
10076   return temp;
10077 }
_internal_mutable_device_attributes()10078 inline ::tensorflow::DeviceAttributes* CompleteGroupRequest::_internal_mutable_device_attributes() {
10079 
10080   if (_impl_.device_attributes_ == nullptr) {
10081     auto* p = CreateMaybeMessage<::tensorflow::DeviceAttributes>(GetArenaForAllocation());
10082     _impl_.device_attributes_ = p;
10083   }
10084   return _impl_.device_attributes_;
10085 }
mutable_device_attributes()10086 inline ::tensorflow::DeviceAttributes* CompleteGroupRequest::mutable_device_attributes() {
10087   ::tensorflow::DeviceAttributes* _msg = _internal_mutable_device_attributes();
10088   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteGroupRequest.device_attributes)
10089   return _msg;
10090 }
set_allocated_device_attributes(::tensorflow::DeviceAttributes * device_attributes)10091 inline void CompleteGroupRequest::set_allocated_device_attributes(::tensorflow::DeviceAttributes* device_attributes) {
10092   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
10093   if (message_arena == nullptr) {
10094     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_attributes_);
10095   }
10096   if (device_attributes) {
10097     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
10098         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
10099                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_attributes));
10100     if (message_arena != submessage_arena) {
10101       device_attributes = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
10102           message_arena, device_attributes, submessage_arena);
10103     }
10104 
10105   } else {
10106 
10107   }
10108   _impl_.device_attributes_ = device_attributes;
10109   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteGroupRequest.device_attributes)
10110 }
10111 
10112 // -------------------------------------------------------------------
10113 
10114 // CompleteGroupResponse
10115 
10116 // int32 group_key = 1;
clear_group_key()10117 inline void CompleteGroupResponse::clear_group_key() {
10118   _impl_.group_key_ = 0;
10119 }
_internal_group_key()10120 inline ::int32_t CompleteGroupResponse::_internal_group_key() const {
10121   return _impl_.group_key_;
10122 }
group_key()10123 inline ::int32_t CompleteGroupResponse::group_key() const {
10124   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupResponse.group_key)
10125   return _internal_group_key();
10126 }
_internal_set_group_key(::int32_t value)10127 inline void CompleteGroupResponse::_internal_set_group_key(::int32_t value) {
10128 
10129   _impl_.group_key_ = value;
10130 }
set_group_key(::int32_t value)10131 inline void CompleteGroupResponse::set_group_key(::int32_t value) {
10132   _internal_set_group_key(value);
10133   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupResponse.group_key)
10134 }
10135 
10136 // int32 group_size = 2;
clear_group_size()10137 inline void CompleteGroupResponse::clear_group_size() {
10138   _impl_.group_size_ = 0;
10139 }
_internal_group_size()10140 inline ::int32_t CompleteGroupResponse::_internal_group_size() const {
10141   return _impl_.group_size_;
10142 }
group_size()10143 inline ::int32_t CompleteGroupResponse::group_size() const {
10144   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupResponse.group_size)
10145   return _internal_group_size();
10146 }
_internal_set_group_size(::int32_t value)10147 inline void CompleteGroupResponse::_internal_set_group_size(::int32_t value) {
10148 
10149   _impl_.group_size_ = value;
10150 }
set_group_size(::int32_t value)10151 inline void CompleteGroupResponse::set_group_size(::int32_t value) {
10152   _internal_set_group_size(value);
10153   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupResponse.group_size)
10154 }
10155 
10156 // string device_type = 3;
clear_device_type()10157 inline void CompleteGroupResponse::clear_device_type() {
10158   _impl_.device_type_.ClearToEmpty();
10159 }
device_type()10160 inline const std::string& CompleteGroupResponse::device_type() const {
10161   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupResponse.device_type)
10162   return _internal_device_type();
10163 }
10164 template <typename ArgT0, typename... ArgT>
10165 inline PROTOBUF_ALWAYS_INLINE
set_device_type(ArgT0 && arg0,ArgT...args)10166 void CompleteGroupResponse::set_device_type(ArgT0&& arg0, ArgT... args) {
10167 
10168  _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
10169   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupResponse.device_type)
10170 }
mutable_device_type()10171 inline std::string* CompleteGroupResponse::mutable_device_type() {
10172   std::string* _s = _internal_mutable_device_type();
10173   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteGroupResponse.device_type)
10174   return _s;
10175 }
_internal_device_type()10176 inline const std::string& CompleteGroupResponse::_internal_device_type() const {
10177   return _impl_.device_type_.Get();
10178 }
_internal_set_device_type(const std::string & value)10179 inline void CompleteGroupResponse::_internal_set_device_type(const std::string& value) {
10180 
10181   _impl_.device_type_.Set(value, GetArenaForAllocation());
10182 }
_internal_mutable_device_type()10183 inline std::string* CompleteGroupResponse::_internal_mutable_device_type() {
10184 
10185   return _impl_.device_type_.Mutable(GetArenaForAllocation());
10186 }
release_device_type()10187 inline std::string* CompleteGroupResponse::release_device_type() {
10188   // @@protoc_insertion_point(field_release:tensorflow.CompleteGroupResponse.device_type)
10189   return _impl_.device_type_.Release();
10190 }
set_allocated_device_type(std::string * device_type)10191 inline void CompleteGroupResponse::set_allocated_device_type(std::string* device_type) {
10192   _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
10193 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10194   if (_impl_.device_type_.IsDefault()) {
10195     _impl_.device_type_.Set("", GetArenaForAllocation());
10196   }
10197 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10198   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteGroupResponse.device_type)
10199 }
10200 
10201 // int32 num_tasks = 4;
clear_num_tasks()10202 inline void CompleteGroupResponse::clear_num_tasks() {
10203   _impl_.num_tasks_ = 0;
10204 }
_internal_num_tasks()10205 inline ::int32_t CompleteGroupResponse::_internal_num_tasks() const {
10206   return _impl_.num_tasks_;
10207 }
num_tasks()10208 inline ::int32_t CompleteGroupResponse::num_tasks() const {
10209   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupResponse.num_tasks)
10210   return _internal_num_tasks();
10211 }
_internal_set_num_tasks(::int32_t value)10212 inline void CompleteGroupResponse::_internal_set_num_tasks(::int32_t value) {
10213 
10214   _impl_.num_tasks_ = value;
10215 }
set_num_tasks(::int32_t value)10216 inline void CompleteGroupResponse::set_num_tasks(::int32_t value) {
10217   _internal_set_num_tasks(value);
10218   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupResponse.num_tasks)
10219 }
10220 
10221 // bytes communicator_key = 7;
clear_communicator_key()10222 inline void CompleteGroupResponse::clear_communicator_key() {
10223   _impl_.communicator_key_.ClearToEmpty();
10224 }
communicator_key()10225 inline const std::string& CompleteGroupResponse::communicator_key() const {
10226   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupResponse.communicator_key)
10227   return _internal_communicator_key();
10228 }
10229 template <typename ArgT0, typename... ArgT>
10230 inline PROTOBUF_ALWAYS_INLINE
set_communicator_key(ArgT0 && arg0,ArgT...args)10231 void CompleteGroupResponse::set_communicator_key(ArgT0&& arg0, ArgT... args) {
10232 
10233  _impl_.communicator_key_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
10234   // @@protoc_insertion_point(field_set:tensorflow.CompleteGroupResponse.communicator_key)
10235 }
mutable_communicator_key()10236 inline std::string* CompleteGroupResponse::mutable_communicator_key() {
10237   std::string* _s = _internal_mutable_communicator_key();
10238   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteGroupResponse.communicator_key)
10239   return _s;
10240 }
_internal_communicator_key()10241 inline const std::string& CompleteGroupResponse::_internal_communicator_key() const {
10242   return _impl_.communicator_key_.Get();
10243 }
_internal_set_communicator_key(const std::string & value)10244 inline void CompleteGroupResponse::_internal_set_communicator_key(const std::string& value) {
10245 
10246   _impl_.communicator_key_.Set(value, GetArenaForAllocation());
10247 }
_internal_mutable_communicator_key()10248 inline std::string* CompleteGroupResponse::_internal_mutable_communicator_key() {
10249 
10250   return _impl_.communicator_key_.Mutable(GetArenaForAllocation());
10251 }
release_communicator_key()10252 inline std::string* CompleteGroupResponse::release_communicator_key() {
10253   // @@protoc_insertion_point(field_release:tensorflow.CompleteGroupResponse.communicator_key)
10254   return _impl_.communicator_key_.Release();
10255 }
set_allocated_communicator_key(std::string * communicator_key)10256 inline void CompleteGroupResponse::set_allocated_communicator_key(std::string* communicator_key) {
10257   _impl_.communicator_key_.SetAllocated(communicator_key, GetArenaForAllocation());
10258 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10259   if (_impl_.communicator_key_.IsDefault()) {
10260     _impl_.communicator_key_.Set("", GetArenaForAllocation());
10261   }
10262 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10263   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteGroupResponse.communicator_key)
10264 }
10265 
10266 // repeated .tensorflow.DeviceAttributes device_attributes = 8;
_internal_device_attributes_size()10267 inline int CompleteGroupResponse::_internal_device_attributes_size() const {
10268   return _impl_.device_attributes_.size();
10269 }
device_attributes_size()10270 inline int CompleteGroupResponse::device_attributes_size() const {
10271   return _internal_device_attributes_size();
10272 }
mutable_device_attributes(int index)10273 inline ::tensorflow::DeviceAttributes* CompleteGroupResponse::mutable_device_attributes(int index) {
10274   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteGroupResponse.device_attributes)
10275   return _impl_.device_attributes_.Mutable(index);
10276 }
10277 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
mutable_device_attributes()10278 CompleteGroupResponse::mutable_device_attributes() {
10279   // @@protoc_insertion_point(field_mutable_list:tensorflow.CompleteGroupResponse.device_attributes)
10280   return &_impl_.device_attributes_;
10281 }
_internal_device_attributes(int index)10282 inline const ::tensorflow::DeviceAttributes& CompleteGroupResponse::_internal_device_attributes(int index) const {
10283   return _impl_.device_attributes_.Get(index);
10284 }
device_attributes(int index)10285 inline const ::tensorflow::DeviceAttributes& CompleteGroupResponse::device_attributes(int index) const {
10286   // @@protoc_insertion_point(field_get:tensorflow.CompleteGroupResponse.device_attributes)
10287   return _internal_device_attributes(index);
10288 }
_internal_add_device_attributes()10289 inline ::tensorflow::DeviceAttributes* CompleteGroupResponse::_internal_add_device_attributes() {
10290   return _impl_.device_attributes_.Add();
10291 }
add_device_attributes()10292 inline ::tensorflow::DeviceAttributes* CompleteGroupResponse::add_device_attributes() {
10293   ::tensorflow::DeviceAttributes* _add = _internal_add_device_attributes();
10294   // @@protoc_insertion_point(field_add:tensorflow.CompleteGroupResponse.device_attributes)
10295   return _add;
10296 }
10297 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
device_attributes()10298 CompleteGroupResponse::device_attributes() const {
10299   // @@protoc_insertion_point(field_list:tensorflow.CompleteGroupResponse.device_attributes)
10300   return _impl_.device_attributes_;
10301 }
10302 
10303 // -------------------------------------------------------------------
10304 
10305 // CompleteInstanceRequest
10306 
10307 // string name = 1;
clear_name()10308 inline void CompleteInstanceRequest::clear_name() {
10309   _impl_.name_.ClearToEmpty();
10310 }
name()10311 inline const std::string& CompleteInstanceRequest::name() const {
10312   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.name)
10313   return _internal_name();
10314 }
10315 template <typename ArgT0, typename... ArgT>
10316 inline PROTOBUF_ALWAYS_INLINE
set_name(ArgT0 && arg0,ArgT...args)10317 void CompleteInstanceRequest::set_name(ArgT0&& arg0, ArgT... args) {
10318 
10319  _impl_.name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
10320   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.name)
10321 }
mutable_name()10322 inline std::string* CompleteInstanceRequest::mutable_name() {
10323   std::string* _s = _internal_mutable_name();
10324   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteInstanceRequest.name)
10325   return _s;
10326 }
_internal_name()10327 inline const std::string& CompleteInstanceRequest::_internal_name() const {
10328   return _impl_.name_.Get();
10329 }
_internal_set_name(const std::string & value)10330 inline void CompleteInstanceRequest::_internal_set_name(const std::string& value) {
10331 
10332   _impl_.name_.Set(value, GetArenaForAllocation());
10333 }
_internal_mutable_name()10334 inline std::string* CompleteInstanceRequest::_internal_mutable_name() {
10335 
10336   return _impl_.name_.Mutable(GetArenaForAllocation());
10337 }
release_name()10338 inline std::string* CompleteInstanceRequest::release_name() {
10339   // @@protoc_insertion_point(field_release:tensorflow.CompleteInstanceRequest.name)
10340   return _impl_.name_.Release();
10341 }
set_allocated_name(std::string * name)10342 inline void CompleteInstanceRequest::set_allocated_name(std::string* name) {
10343   _impl_.name_.SetAllocated(name, GetArenaForAllocation());
10344 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10345   if (_impl_.name_.IsDefault()) {
10346     _impl_.name_.Set("", GetArenaForAllocation());
10347   }
10348 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10349   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteInstanceRequest.name)
10350 }
10351 
10352 // int32 type = 2;
clear_type()10353 inline void CompleteInstanceRequest::clear_type() {
10354   _impl_.type_ = 0;
10355 }
_internal_type()10356 inline ::int32_t CompleteInstanceRequest::_internal_type() const {
10357   return _impl_.type_;
10358 }
type()10359 inline ::int32_t CompleteInstanceRequest::type() const {
10360   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.type)
10361   return _internal_type();
10362 }
_internal_set_type(::int32_t value)10363 inline void CompleteInstanceRequest::_internal_set_type(::int32_t value) {
10364 
10365   _impl_.type_ = value;
10366 }
set_type(::int32_t value)10367 inline void CompleteInstanceRequest::set_type(::int32_t value) {
10368   _internal_set_type(value);
10369   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.type)
10370 }
10371 
10372 // .tensorflow.DataType data_type = 3;
clear_data_type()10373 inline void CompleteInstanceRequest::clear_data_type() {
10374   _impl_.data_type_ = 0;
10375 }
_internal_data_type()10376 inline ::tensorflow::DataType CompleteInstanceRequest::_internal_data_type() const {
10377   return static_cast< ::tensorflow::DataType >(_impl_.data_type_);
10378 }
data_type()10379 inline ::tensorflow::DataType CompleteInstanceRequest::data_type() const {
10380   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.data_type)
10381   return _internal_data_type();
10382 }
_internal_set_data_type(::tensorflow::DataType value)10383 inline void CompleteInstanceRequest::_internal_set_data_type(::tensorflow::DataType value) {
10384 
10385   _impl_.data_type_ = value;
10386 }
set_data_type(::tensorflow::DataType value)10387 inline void CompleteInstanceRequest::set_data_type(::tensorflow::DataType value) {
10388   _internal_set_data_type(value);
10389   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.data_type)
10390 }
10391 
10392 // .tensorflow.TensorShapeProto shape = 4;
_internal_has_shape()10393 inline bool CompleteInstanceRequest::_internal_has_shape() const {
10394   return this != internal_default_instance() && _impl_.shape_ != nullptr;
10395 }
has_shape()10396 inline bool CompleteInstanceRequest::has_shape() const {
10397   return _internal_has_shape();
10398 }
_internal_shape()10399 inline const ::tensorflow::TensorShapeProto& CompleteInstanceRequest::_internal_shape() const {
10400   const ::tensorflow::TensorShapeProto* p = _impl_.shape_;
10401   return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::TensorShapeProto&>(
10402       ::tensorflow::_TensorShapeProto_default_instance_);
10403 }
shape()10404 inline const ::tensorflow::TensorShapeProto& CompleteInstanceRequest::shape() const {
10405   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.shape)
10406   return _internal_shape();
10407 }
unsafe_arena_set_allocated_shape(::tensorflow::TensorShapeProto * shape)10408 inline void CompleteInstanceRequest::unsafe_arena_set_allocated_shape(
10409     ::tensorflow::TensorShapeProto* shape) {
10410   if (GetArenaForAllocation() == nullptr) {
10411     delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
10412   }
10413   _impl_.shape_ = shape;
10414   // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CompleteInstanceRequest.shape)
10415 }
release_shape()10416 inline ::tensorflow::TensorShapeProto* CompleteInstanceRequest::release_shape() {
10417 
10418   ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
10419   _impl_.shape_ = nullptr;
10420 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
10421   auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
10422   temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
10423   if (GetArenaForAllocation() == nullptr) { delete old; }
10424 #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
10425   if (GetArenaForAllocation() != nullptr) {
10426     temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
10427   }
10428 #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
10429   return temp;
10430 }
unsafe_arena_release_shape()10431 inline ::tensorflow::TensorShapeProto* CompleteInstanceRequest::unsafe_arena_release_shape() {
10432   // @@protoc_insertion_point(field_release:tensorflow.CompleteInstanceRequest.shape)
10433 
10434   ::tensorflow::TensorShapeProto* temp = _impl_.shape_;
10435   _impl_.shape_ = nullptr;
10436   return temp;
10437 }
_internal_mutable_shape()10438 inline ::tensorflow::TensorShapeProto* CompleteInstanceRequest::_internal_mutable_shape() {
10439 
10440   if (_impl_.shape_ == nullptr) {
10441     auto* p = CreateMaybeMessage<::tensorflow::TensorShapeProto>(GetArenaForAllocation());
10442     _impl_.shape_ = p;
10443   }
10444   return _impl_.shape_;
10445 }
mutable_shape()10446 inline ::tensorflow::TensorShapeProto* CompleteInstanceRequest::mutable_shape() {
10447   ::tensorflow::TensorShapeProto* _msg = _internal_mutable_shape();
10448   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteInstanceRequest.shape)
10449   return _msg;
10450 }
set_allocated_shape(::tensorflow::TensorShapeProto * shape)10451 inline void CompleteInstanceRequest::set_allocated_shape(::tensorflow::TensorShapeProto* shape) {
10452   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
10453   if (message_arena == nullptr) {
10454     delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_);
10455   }
10456   if (shape) {
10457     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
10458         ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
10459                 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape));
10460     if (message_arena != submessage_arena) {
10461       shape = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
10462           message_arena, shape, submessage_arena);
10463     }
10464 
10465   } else {
10466 
10467   }
10468   _impl_.shape_ = shape;
10469   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteInstanceRequest.shape)
10470 }
10471 
10472 // int32 group_key = 5;
clear_group_key()10473 inline void CompleteInstanceRequest::clear_group_key() {
10474   _impl_.group_key_ = 0;
10475 }
_internal_group_key()10476 inline ::int32_t CompleteInstanceRequest::_internal_group_key() const {
10477   return _impl_.group_key_;
10478 }
group_key()10479 inline ::int32_t CompleteInstanceRequest::group_key() const {
10480   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.group_key)
10481   return _internal_group_key();
10482 }
_internal_set_group_key(::int32_t value)10483 inline void CompleteInstanceRequest::_internal_set_group_key(::int32_t value) {
10484 
10485   _impl_.group_key_ = value;
10486 }
set_group_key(::int32_t value)10487 inline void CompleteInstanceRequest::set_group_key(::int32_t value) {
10488   _internal_set_group_key(value);
10489   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.group_key)
10490 }
10491 
10492 // int32 group_size = 6;
clear_group_size()10493 inline void CompleteInstanceRequest::clear_group_size() {
10494   _impl_.group_size_ = 0;
10495 }
_internal_group_size()10496 inline ::int32_t CompleteInstanceRequest::_internal_group_size() const {
10497   return _impl_.group_size_;
10498 }
group_size()10499 inline ::int32_t CompleteInstanceRequest::group_size() const {
10500   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.group_size)
10501   return _internal_group_size();
10502 }
_internal_set_group_size(::int32_t value)10503 inline void CompleteInstanceRequest::_internal_set_group_size(::int32_t value) {
10504 
10505   _impl_.group_size_ = value;
10506 }
set_group_size(::int32_t value)10507 inline void CompleteInstanceRequest::set_group_size(::int32_t value) {
10508   _internal_set_group_size(value);
10509   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.group_size)
10510 }
10511 
10512 // int32 instance_key = 7;
clear_instance_key()10513 inline void CompleteInstanceRequest::clear_instance_key() {
10514   _impl_.instance_key_ = 0;
10515 }
_internal_instance_key()10516 inline ::int32_t CompleteInstanceRequest::_internal_instance_key() const {
10517   return _impl_.instance_key_;
10518 }
instance_key()10519 inline ::int32_t CompleteInstanceRequest::instance_key() const {
10520   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.instance_key)
10521   return _internal_instance_key();
10522 }
_internal_set_instance_key(::int32_t value)10523 inline void CompleteInstanceRequest::_internal_set_instance_key(::int32_t value) {
10524 
10525   _impl_.instance_key_ = value;
10526 }
set_instance_key(::int32_t value)10527 inline void CompleteInstanceRequest::set_instance_key(::int32_t value) {
10528   _internal_set_instance_key(value);
10529   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.instance_key)
10530 }
10531 
10532 // string device_type = 8;
clear_device_type()10533 inline void CompleteInstanceRequest::clear_device_type() {
10534   _impl_.device_type_.ClearToEmpty();
10535 }
device_type()10536 inline const std::string& CompleteInstanceRequest::device_type() const {
10537   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.device_type)
10538   return _internal_device_type();
10539 }
10540 template <typename ArgT0, typename... ArgT>
10541 inline PROTOBUF_ALWAYS_INLINE
set_device_type(ArgT0 && arg0,ArgT...args)10542 void CompleteInstanceRequest::set_device_type(ArgT0&& arg0, ArgT... args) {
10543 
10544  _impl_.device_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
10545   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.device_type)
10546 }
mutable_device_type()10547 inline std::string* CompleteInstanceRequest::mutable_device_type() {
10548   std::string* _s = _internal_mutable_device_type();
10549   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteInstanceRequest.device_type)
10550   return _s;
10551 }
_internal_device_type()10552 inline const std::string& CompleteInstanceRequest::_internal_device_type() const {
10553   return _impl_.device_type_.Get();
10554 }
_internal_set_device_type(const std::string & value)10555 inline void CompleteInstanceRequest::_internal_set_device_type(const std::string& value) {
10556 
10557   _impl_.device_type_.Set(value, GetArenaForAllocation());
10558 }
_internal_mutable_device_type()10559 inline std::string* CompleteInstanceRequest::_internal_mutable_device_type() {
10560 
10561   return _impl_.device_type_.Mutable(GetArenaForAllocation());
10562 }
release_device_type()10563 inline std::string* CompleteInstanceRequest::release_device_type() {
10564   // @@protoc_insertion_point(field_release:tensorflow.CompleteInstanceRequest.device_type)
10565   return _impl_.device_type_.Release();
10566 }
set_allocated_device_type(std::string * device_type)10567 inline void CompleteInstanceRequest::set_allocated_device_type(std::string* device_type) {
10568   _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation());
10569 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10570   if (_impl_.device_type_.IsDefault()) {
10571     _impl_.device_type_.Set("", GetArenaForAllocation());
10572   }
10573 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10574   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteInstanceRequest.device_type)
10575 }
10576 
10577 // repeated int32 subdiv_offset = 9;
_internal_subdiv_offset_size()10578 inline int CompleteInstanceRequest::_internal_subdiv_offset_size() const {
10579   return _impl_.subdiv_offset_.size();
10580 }
subdiv_offset_size()10581 inline int CompleteInstanceRequest::subdiv_offset_size() const {
10582   return _internal_subdiv_offset_size();
10583 }
clear_subdiv_offset()10584 inline void CompleteInstanceRequest::clear_subdiv_offset() {
10585   _impl_.subdiv_offset_.Clear();
10586 }
_internal_subdiv_offset(int index)10587 inline ::int32_t CompleteInstanceRequest::_internal_subdiv_offset(int index) const {
10588   return _impl_.subdiv_offset_.Get(index);
10589 }
subdiv_offset(int index)10590 inline ::int32_t CompleteInstanceRequest::subdiv_offset(int index) const {
10591   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.subdiv_offset)
10592   return _internal_subdiv_offset(index);
10593 }
set_subdiv_offset(int index,::int32_t value)10594 inline void CompleteInstanceRequest::set_subdiv_offset(int index, ::int32_t value) {
10595   _impl_.subdiv_offset_.Set(index, value);
10596   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.subdiv_offset)
10597 }
_internal_add_subdiv_offset(::int32_t value)10598 inline void CompleteInstanceRequest::_internal_add_subdiv_offset(::int32_t value) {
10599   _impl_.subdiv_offset_.Add(value);
10600 }
add_subdiv_offset(::int32_t value)10601 inline void CompleteInstanceRequest::add_subdiv_offset(::int32_t value) {
10602   _internal_add_subdiv_offset(value);
10603   // @@protoc_insertion_point(field_add:tensorflow.CompleteInstanceRequest.subdiv_offset)
10604 }
10605 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
_internal_subdiv_offset()10606 CompleteInstanceRequest::_internal_subdiv_offset() const {
10607   return _impl_.subdiv_offset_;
10608 }
10609 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >&
subdiv_offset()10610 CompleteInstanceRequest::subdiv_offset() const {
10611   // @@protoc_insertion_point(field_list:tensorflow.CompleteInstanceRequest.subdiv_offset)
10612   return _internal_subdiv_offset();
10613 }
10614 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
_internal_mutable_subdiv_offset()10615 CompleteInstanceRequest::_internal_mutable_subdiv_offset() {
10616   return &_impl_.subdiv_offset_;
10617 }
10618 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int32_t >*
mutable_subdiv_offset()10619 CompleteInstanceRequest::mutable_subdiv_offset() {
10620   // @@protoc_insertion_point(field_mutable_list:tensorflow.CompleteInstanceRequest.subdiv_offset)
10621   return _internal_mutable_subdiv_offset();
10622 }
10623 
10624 // string device = 10;
clear_device()10625 inline void CompleteInstanceRequest::clear_device() {
10626   _impl_.device_.ClearToEmpty();
10627 }
device()10628 inline const std::string& CompleteInstanceRequest::device() const {
10629   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.device)
10630   return _internal_device();
10631 }
10632 template <typename ArgT0, typename... ArgT>
10633 inline PROTOBUF_ALWAYS_INLINE
set_device(ArgT0 && arg0,ArgT...args)10634 void CompleteInstanceRequest::set_device(ArgT0&& arg0, ArgT... args) {
10635 
10636  _impl_.device_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
10637   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.device)
10638 }
mutable_device()10639 inline std::string* CompleteInstanceRequest::mutable_device() {
10640   std::string* _s = _internal_mutable_device();
10641   // @@protoc_insertion_point(field_mutable:tensorflow.CompleteInstanceRequest.device)
10642   return _s;
10643 }
_internal_device()10644 inline const std::string& CompleteInstanceRequest::_internal_device() const {
10645   return _impl_.device_.Get();
10646 }
_internal_set_device(const std::string & value)10647 inline void CompleteInstanceRequest::_internal_set_device(const std::string& value) {
10648 
10649   _impl_.device_.Set(value, GetArenaForAllocation());
10650 }
_internal_mutable_device()10651 inline std::string* CompleteInstanceRequest::_internal_mutable_device() {
10652 
10653   return _impl_.device_.Mutable(GetArenaForAllocation());
10654 }
release_device()10655 inline std::string* CompleteInstanceRequest::release_device() {
10656   // @@protoc_insertion_point(field_release:tensorflow.CompleteInstanceRequest.device)
10657   return _impl_.device_.Release();
10658 }
set_allocated_device(std::string * device)10659 inline void CompleteInstanceRequest::set_allocated_device(std::string* device) {
10660   _impl_.device_.SetAllocated(device, GetArenaForAllocation());
10661 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
10662   if (_impl_.device_.IsDefault()) {
10663     _impl_.device_.Set("", GetArenaForAllocation());
10664   }
10665 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
10666   // @@protoc_insertion_point(field_set_allocated:tensorflow.CompleteInstanceRequest.device)
10667 }
10668 
10669 // bool is_source = 11;
clear_is_source()10670 inline void CompleteInstanceRequest::clear_is_source() {
10671   _impl_.is_source_ = false;
10672 }
_internal_is_source()10673 inline bool CompleteInstanceRequest::_internal_is_source() const {
10674   return _impl_.is_source_;
10675 }
is_source()10676 inline bool CompleteInstanceRequest::is_source() const {
10677   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceRequest.is_source)
10678   return _internal_is_source();
10679 }
_internal_set_is_source(bool value)10680 inline void CompleteInstanceRequest::_internal_set_is_source(bool value) {
10681 
10682   _impl_.is_source_ = value;
10683 }
set_is_source(bool value)10684 inline void CompleteInstanceRequest::set_is_source(bool value) {
10685   _internal_set_is_source(value);
10686   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceRequest.is_source)
10687 }
10688 
10689 // -------------------------------------------------------------------
10690 
10691 // CompleteInstanceResponse
10692 
10693 // int32 instance_key = 1;
clear_instance_key()10694 inline void CompleteInstanceResponse::clear_instance_key() {
10695   _impl_.instance_key_ = 0;
10696 }
_internal_instance_key()10697 inline ::int32_t CompleteInstanceResponse::_internal_instance_key() const {
10698   return _impl_.instance_key_;
10699 }
instance_key()10700 inline ::int32_t CompleteInstanceResponse::instance_key() const {
10701   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceResponse.instance_key)
10702   return _internal_instance_key();
10703 }
_internal_set_instance_key(::int32_t value)10704 inline void CompleteInstanceResponse::_internal_set_instance_key(::int32_t value) {
10705 
10706   _impl_.instance_key_ = value;
10707 }
set_instance_key(::int32_t value)10708 inline void CompleteInstanceResponse::set_instance_key(::int32_t value) {
10709   _internal_set_instance_key(value);
10710   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceResponse.instance_key)
10711 }
10712 
10713 // int32 source_rank = 2;
clear_source_rank()10714 inline void CompleteInstanceResponse::clear_source_rank() {
10715   _impl_.source_rank_ = 0;
10716 }
_internal_source_rank()10717 inline ::int32_t CompleteInstanceResponse::_internal_source_rank() const {
10718   return _impl_.source_rank_;
10719 }
source_rank()10720 inline ::int32_t CompleteInstanceResponse::source_rank() const {
10721   // @@protoc_insertion_point(field_get:tensorflow.CompleteInstanceResponse.source_rank)
10722   return _internal_source_rank();
10723 }
_internal_set_source_rank(::int32_t value)10724 inline void CompleteInstanceResponse::_internal_set_source_rank(::int32_t value) {
10725 
10726   _impl_.source_rank_ = value;
10727 }
set_source_rank(::int32_t value)10728 inline void CompleteInstanceResponse::set_source_rank(::int32_t value) {
10729   _internal_set_source_rank(value);
10730   // @@protoc_insertion_point(field_set:tensorflow.CompleteInstanceResponse.source_rank)
10731 }
10732 
10733 // -------------------------------------------------------------------
10734 
10735 // GetStepSequenceRequest
10736 
10737 // repeated int64 graph_key = 1;
_internal_graph_key_size()10738 inline int GetStepSequenceRequest::_internal_graph_key_size() const {
10739   return _impl_.graph_key_.size();
10740 }
graph_key_size()10741 inline int GetStepSequenceRequest::graph_key_size() const {
10742   return _internal_graph_key_size();
10743 }
clear_graph_key()10744 inline void GetStepSequenceRequest::clear_graph_key() {
10745   _impl_.graph_key_.Clear();
10746 }
_internal_graph_key(int index)10747 inline ::int64_t GetStepSequenceRequest::_internal_graph_key(int index) const {
10748   return _impl_.graph_key_.Get(index);
10749 }
graph_key(int index)10750 inline ::int64_t GetStepSequenceRequest::graph_key(int index) const {
10751   // @@protoc_insertion_point(field_get:tensorflow.GetStepSequenceRequest.graph_key)
10752   return _internal_graph_key(index);
10753 }
set_graph_key(int index,::int64_t value)10754 inline void GetStepSequenceRequest::set_graph_key(int index, ::int64_t value) {
10755   _impl_.graph_key_.Set(index, value);
10756   // @@protoc_insertion_point(field_set:tensorflow.GetStepSequenceRequest.graph_key)
10757 }
_internal_add_graph_key(::int64_t value)10758 inline void GetStepSequenceRequest::_internal_add_graph_key(::int64_t value) {
10759   _impl_.graph_key_.Add(value);
10760 }
add_graph_key(::int64_t value)10761 inline void GetStepSequenceRequest::add_graph_key(::int64_t value) {
10762   _internal_add_graph_key(value);
10763   // @@protoc_insertion_point(field_add:tensorflow.GetStepSequenceRequest.graph_key)
10764 }
10765 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
_internal_graph_key()10766 GetStepSequenceRequest::_internal_graph_key() const {
10767   return _impl_.graph_key_;
10768 }
10769 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >&
graph_key()10770 GetStepSequenceRequest::graph_key() const {
10771   // @@protoc_insertion_point(field_list:tensorflow.GetStepSequenceRequest.graph_key)
10772   return _internal_graph_key();
10773 }
10774 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
_internal_mutable_graph_key()10775 GetStepSequenceRequest::_internal_mutable_graph_key() {
10776   return &_impl_.graph_key_;
10777 }
10778 inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::int64_t >*
mutable_graph_key()10779 GetStepSequenceRequest::mutable_graph_key() {
10780   // @@protoc_insertion_point(field_mutable_list:tensorflow.GetStepSequenceRequest.graph_key)
10781   return _internal_mutable_graph_key();
10782 }
10783 
10784 // -------------------------------------------------------------------
10785 
10786 // StepSequence
10787 
10788 // int64 graph_key = 1;
clear_graph_key()10789 inline void StepSequence::clear_graph_key() {
10790   _impl_.graph_key_ = ::int64_t{0};
10791 }
_internal_graph_key()10792 inline ::int64_t StepSequence::_internal_graph_key() const {
10793   return _impl_.graph_key_;
10794 }
graph_key()10795 inline ::int64_t StepSequence::graph_key() const {
10796   // @@protoc_insertion_point(field_get:tensorflow.StepSequence.graph_key)
10797   return _internal_graph_key();
10798 }
_internal_set_graph_key(::int64_t value)10799 inline void StepSequence::_internal_set_graph_key(::int64_t value) {
10800 
10801   _impl_.graph_key_ = value;
10802 }
set_graph_key(::int64_t value)10803 inline void StepSequence::set_graph_key(::int64_t value) {
10804   _internal_set_graph_key(value);
10805   // @@protoc_insertion_point(field_set:tensorflow.StepSequence.graph_key)
10806 }
10807 
10808 // int64 next_step_id = 2;
clear_next_step_id()10809 inline void StepSequence::clear_next_step_id() {
10810   _impl_.next_step_id_ = ::int64_t{0};
10811 }
_internal_next_step_id()10812 inline ::int64_t StepSequence::_internal_next_step_id() const {
10813   return _impl_.next_step_id_;
10814 }
next_step_id()10815 inline ::int64_t StepSequence::next_step_id() const {
10816   // @@protoc_insertion_point(field_get:tensorflow.StepSequence.next_step_id)
10817   return _internal_next_step_id();
10818 }
_internal_set_next_step_id(::int64_t value)10819 inline void StepSequence::_internal_set_next_step_id(::int64_t value) {
10820 
10821   _impl_.next_step_id_ = value;
10822 }
set_next_step_id(::int64_t value)10823 inline void StepSequence::set_next_step_id(::int64_t value) {
10824   _internal_set_next_step_id(value);
10825   // @@protoc_insertion_point(field_set:tensorflow.StepSequence.next_step_id)
10826 }
10827 
10828 // -------------------------------------------------------------------
10829 
10830 // GetStepSequenceResponse
10831 
10832 // repeated .tensorflow.StepSequence step_sequence = 1;
_internal_step_sequence_size()10833 inline int GetStepSequenceResponse::_internal_step_sequence_size() const {
10834   return _impl_.step_sequence_.size();
10835 }
step_sequence_size()10836 inline int GetStepSequenceResponse::step_sequence_size() const {
10837   return _internal_step_sequence_size();
10838 }
clear_step_sequence()10839 inline void GetStepSequenceResponse::clear_step_sequence() {
10840   _impl_.step_sequence_.Clear();
10841 }
mutable_step_sequence(int index)10842 inline ::tensorflow::StepSequence* GetStepSequenceResponse::mutable_step_sequence(int index) {
10843   // @@protoc_insertion_point(field_mutable:tensorflow.GetStepSequenceResponse.step_sequence)
10844   return _impl_.step_sequence_.Mutable(index);
10845 }
10846 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StepSequence >*
mutable_step_sequence()10847 GetStepSequenceResponse::mutable_step_sequence() {
10848   // @@protoc_insertion_point(field_mutable_list:tensorflow.GetStepSequenceResponse.step_sequence)
10849   return &_impl_.step_sequence_;
10850 }
_internal_step_sequence(int index)10851 inline const ::tensorflow::StepSequence& GetStepSequenceResponse::_internal_step_sequence(int index) const {
10852   return _impl_.step_sequence_.Get(index);
10853 }
step_sequence(int index)10854 inline const ::tensorflow::StepSequence& GetStepSequenceResponse::step_sequence(int index) const {
10855   // @@protoc_insertion_point(field_get:tensorflow.GetStepSequenceResponse.step_sequence)
10856   return _internal_step_sequence(index);
10857 }
_internal_add_step_sequence()10858 inline ::tensorflow::StepSequence* GetStepSequenceResponse::_internal_add_step_sequence() {
10859   return _impl_.step_sequence_.Add();
10860 }
add_step_sequence()10861 inline ::tensorflow::StepSequence* GetStepSequenceResponse::add_step_sequence() {
10862   ::tensorflow::StepSequence* _add = _internal_add_step_sequence();
10863   // @@protoc_insertion_point(field_add:tensorflow.GetStepSequenceResponse.step_sequence)
10864   return _add;
10865 }
10866 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::StepSequence >&
step_sequence()10867 GetStepSequenceResponse::step_sequence() const {
10868   // @@protoc_insertion_point(field_list:tensorflow.GetStepSequenceResponse.step_sequence)
10869   return _impl_.step_sequence_;
10870 }
10871 
10872 #ifdef __GNUC__
10873   #pragma GCC diagnostic pop
10874 #endif  // __GNUC__
10875 // -------------------------------------------------------------------
10876 
10877 // -------------------------------------------------------------------
10878 
10879 // -------------------------------------------------------------------
10880 
10881 // -------------------------------------------------------------------
10882 
10883 // -------------------------------------------------------------------
10884 
10885 // -------------------------------------------------------------------
10886 
10887 // -------------------------------------------------------------------
10888 
10889 // -------------------------------------------------------------------
10890 
10891 // -------------------------------------------------------------------
10892 
10893 // -------------------------------------------------------------------
10894 
10895 // -------------------------------------------------------------------
10896 
10897 // -------------------------------------------------------------------
10898 
10899 // -------------------------------------------------------------------
10900 
10901 // -------------------------------------------------------------------
10902 
10903 // -------------------------------------------------------------------
10904 
10905 // -------------------------------------------------------------------
10906 
10907 // -------------------------------------------------------------------
10908 
10909 // -------------------------------------------------------------------
10910 
10911 // -------------------------------------------------------------------
10912 
10913 // -------------------------------------------------------------------
10914 
10915 // -------------------------------------------------------------------
10916 
10917 // -------------------------------------------------------------------
10918 
10919 // -------------------------------------------------------------------
10920 
10921 // -------------------------------------------------------------------
10922 
10923 // -------------------------------------------------------------------
10924 
10925 // -------------------------------------------------------------------
10926 
10927 // -------------------------------------------------------------------
10928 
10929 // -------------------------------------------------------------------
10930 
10931 // -------------------------------------------------------------------
10932 
10933 // -------------------------------------------------------------------
10934 
10935 // -------------------------------------------------------------------
10936 
10937 // -------------------------------------------------------------------
10938 
10939 // -------------------------------------------------------------------
10940 
10941 // -------------------------------------------------------------------
10942 
10943 // -------------------------------------------------------------------
10944 
10945 
10946 // @@protoc_insertion_point(namespace_scope)
10947 
10948 }  // namespace tensorflow
10949 
10950 // @@protoc_insertion_point(global_scope)
10951 
10952 #include <google/protobuf/port_undef.inc>
10953 #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fworker_2eproto
10954