1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/master.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fmaster_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 "tensorflow/core/framework/device_attributes.pb.h"
33 #include "tensorflow/core/framework/graph.pb.h"
34 #include "tensorflow/core/framework/tensor.pb.h"
35 #include "tensorflow/core/protobuf/config.pb.h"
36 #include "tensorflow/core/protobuf/error_codes.pb.h"
37 #include "tensorflow/core/protobuf/named_tensor.pb.h"
38 // @@protoc_insertion_point(includes)
39 #include <google/protobuf/port_def.inc>
40 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto
41 PROTOBUF_NAMESPACE_OPEN
42 namespace internal {
43 class AnyMetadata;
44 } // namespace internal
45 PROTOBUF_NAMESPACE_CLOSE
46
47 // Internal implementation detail -- do not use these members.
48 struct TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto {
49 static const ::uint32_t offsets[];
50 };
51 namespace tensorflow {
52 class CloseSessionRequest;
53 struct CloseSessionRequestDefaultTypeInternal;
54 extern CloseSessionRequestDefaultTypeInternal _CloseSessionRequest_default_instance_;
55 class CloseSessionResponse;
56 struct CloseSessionResponseDefaultTypeInternal;
57 extern CloseSessionResponseDefaultTypeInternal _CloseSessionResponse_default_instance_;
58 class CreateSessionRequest;
59 struct CreateSessionRequestDefaultTypeInternal;
60 extern CreateSessionRequestDefaultTypeInternal _CreateSessionRequest_default_instance_;
61 class CreateSessionResponse;
62 struct CreateSessionResponseDefaultTypeInternal;
63 extern CreateSessionResponseDefaultTypeInternal _CreateSessionResponse_default_instance_;
64 class ExtendSessionRequest;
65 struct ExtendSessionRequestDefaultTypeInternal;
66 extern ExtendSessionRequestDefaultTypeInternal _ExtendSessionRequest_default_instance_;
67 class ExtendSessionResponse;
68 struct ExtendSessionResponseDefaultTypeInternal;
69 extern ExtendSessionResponseDefaultTypeInternal _ExtendSessionResponse_default_instance_;
70 class ListDevicesRequest;
71 struct ListDevicesRequestDefaultTypeInternal;
72 extern ListDevicesRequestDefaultTypeInternal _ListDevicesRequest_default_instance_;
73 class ListDevicesResponse;
74 struct ListDevicesResponseDefaultTypeInternal;
75 extern ListDevicesResponseDefaultTypeInternal _ListDevicesResponse_default_instance_;
76 class MakeCallableRequest;
77 struct MakeCallableRequestDefaultTypeInternal;
78 extern MakeCallableRequestDefaultTypeInternal _MakeCallableRequest_default_instance_;
79 class MakeCallableResponse;
80 struct MakeCallableResponseDefaultTypeInternal;
81 extern MakeCallableResponseDefaultTypeInternal _MakeCallableResponse_default_instance_;
82 class PartialRunSetupRequest;
83 struct PartialRunSetupRequestDefaultTypeInternal;
84 extern PartialRunSetupRequestDefaultTypeInternal _PartialRunSetupRequest_default_instance_;
85 class PartialRunSetupResponse;
86 struct PartialRunSetupResponseDefaultTypeInternal;
87 extern PartialRunSetupResponseDefaultTypeInternal _PartialRunSetupResponse_default_instance_;
88 class ReleaseCallableRequest;
89 struct ReleaseCallableRequestDefaultTypeInternal;
90 extern ReleaseCallableRequestDefaultTypeInternal _ReleaseCallableRequest_default_instance_;
91 class ReleaseCallableResponse;
92 struct ReleaseCallableResponseDefaultTypeInternal;
93 extern ReleaseCallableResponseDefaultTypeInternal _ReleaseCallableResponse_default_instance_;
94 class ResetRequest;
95 struct ResetRequestDefaultTypeInternal;
96 extern ResetRequestDefaultTypeInternal _ResetRequest_default_instance_;
97 class ResetResponse;
98 struct ResetResponseDefaultTypeInternal;
99 extern ResetResponseDefaultTypeInternal _ResetResponse_default_instance_;
100 class RunCallableRequest;
101 struct RunCallableRequestDefaultTypeInternal;
102 extern RunCallableRequestDefaultTypeInternal _RunCallableRequest_default_instance_;
103 class RunCallableResponse;
104 struct RunCallableResponseDefaultTypeInternal;
105 extern RunCallableResponseDefaultTypeInternal _RunCallableResponse_default_instance_;
106 class RunStepRequest;
107 struct RunStepRequestDefaultTypeInternal;
108 extern RunStepRequestDefaultTypeInternal _RunStepRequest_default_instance_;
109 class RunStepResponse;
110 struct RunStepResponseDefaultTypeInternal;
111 extern RunStepResponseDefaultTypeInternal _RunStepResponse_default_instance_;
112 } // namespace tensorflow
113 PROTOBUF_NAMESPACE_OPEN
114 template<> ::tensorflow::CloseSessionRequest* Arena::CreateMaybeMessage<::tensorflow::CloseSessionRequest>(Arena*);
115 template<> ::tensorflow::CloseSessionResponse* Arena::CreateMaybeMessage<::tensorflow::CloseSessionResponse>(Arena*);
116 template<> ::tensorflow::CreateSessionRequest* Arena::CreateMaybeMessage<::tensorflow::CreateSessionRequest>(Arena*);
117 template<> ::tensorflow::CreateSessionResponse* Arena::CreateMaybeMessage<::tensorflow::CreateSessionResponse>(Arena*);
118 template<> ::tensorflow::ExtendSessionRequest* Arena::CreateMaybeMessage<::tensorflow::ExtendSessionRequest>(Arena*);
119 template<> ::tensorflow::ExtendSessionResponse* Arena::CreateMaybeMessage<::tensorflow::ExtendSessionResponse>(Arena*);
120 template<> ::tensorflow::ListDevicesRequest* Arena::CreateMaybeMessage<::tensorflow::ListDevicesRequest>(Arena*);
121 template<> ::tensorflow::ListDevicesResponse* Arena::CreateMaybeMessage<::tensorflow::ListDevicesResponse>(Arena*);
122 template<> ::tensorflow::MakeCallableRequest* Arena::CreateMaybeMessage<::tensorflow::MakeCallableRequest>(Arena*);
123 template<> ::tensorflow::MakeCallableResponse* Arena::CreateMaybeMessage<::tensorflow::MakeCallableResponse>(Arena*);
124 template<> ::tensorflow::PartialRunSetupRequest* Arena::CreateMaybeMessage<::tensorflow::PartialRunSetupRequest>(Arena*);
125 template<> ::tensorflow::PartialRunSetupResponse* Arena::CreateMaybeMessage<::tensorflow::PartialRunSetupResponse>(Arena*);
126 template<> ::tensorflow::ReleaseCallableRequest* Arena::CreateMaybeMessage<::tensorflow::ReleaseCallableRequest>(Arena*);
127 template<> ::tensorflow::ReleaseCallableResponse* Arena::CreateMaybeMessage<::tensorflow::ReleaseCallableResponse>(Arena*);
128 template<> ::tensorflow::ResetRequest* Arena::CreateMaybeMessage<::tensorflow::ResetRequest>(Arena*);
129 template<> ::tensorflow::ResetResponse* Arena::CreateMaybeMessage<::tensorflow::ResetResponse>(Arena*);
130 template<> ::tensorflow::RunCallableRequest* Arena::CreateMaybeMessage<::tensorflow::RunCallableRequest>(Arena*);
131 template<> ::tensorflow::RunCallableResponse* Arena::CreateMaybeMessage<::tensorflow::RunCallableResponse>(Arena*);
132 template<> ::tensorflow::RunStepRequest* Arena::CreateMaybeMessage<::tensorflow::RunStepRequest>(Arena*);
133 template<> ::tensorflow::RunStepResponse* Arena::CreateMaybeMessage<::tensorflow::RunStepResponse>(Arena*);
134 PROTOBUF_NAMESPACE_CLOSE
135 namespace tensorflow {
136
137 // ===================================================================
138
139 class CreateSessionRequest final :
140 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CreateSessionRequest) */ {
141 public:
CreateSessionRequest()142 inline CreateSessionRequest() : CreateSessionRequest(nullptr) {}
143 ~CreateSessionRequest() override;
144 explicit PROTOBUF_CONSTEXPR CreateSessionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
145
146 CreateSessionRequest(const CreateSessionRequest& from);
CreateSessionRequest(CreateSessionRequest && from)147 CreateSessionRequest(CreateSessionRequest&& from) noexcept
148 : CreateSessionRequest() {
149 *this = ::std::move(from);
150 }
151
152 inline CreateSessionRequest& operator=(const CreateSessionRequest& from) {
153 if (this == &from) return *this;
154 CopyFrom(from);
155 return *this;
156 }
157 inline CreateSessionRequest& operator=(CreateSessionRequest&& from) noexcept {
158 if (this == &from) return *this;
159 if (GetOwningArena() == from.GetOwningArena()
160 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
161 && GetOwningArena() != nullptr
162 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
163 ) {
164 InternalSwap(&from);
165 } else {
166 CopyFrom(from);
167 }
168 return *this;
169 }
170
default_instance()171 static const CreateSessionRequest& default_instance() {
172 return *internal_default_instance();
173 }
internal_default_instance()174 static inline const CreateSessionRequest* internal_default_instance() {
175 return reinterpret_cast<const CreateSessionRequest*>(
176 &_CreateSessionRequest_default_instance_);
177 }
178 static constexpr int kIndexInFileMessages =
179 0;
180
swap(CreateSessionRequest & a,CreateSessionRequest & b)181 friend void swap(CreateSessionRequest& a, CreateSessionRequest& b) {
182 a.Swap(&b);
183 }
Swap(CreateSessionRequest * other)184 inline void Swap(CreateSessionRequest* other) {
185 if (other == this) return;
186 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
187 if (GetOwningArena() != nullptr &&
188 GetOwningArena() == other->GetOwningArena()) {
189 #else // PROTOBUF_FORCE_COPY_IN_SWAP
190 if (GetOwningArena() == other->GetOwningArena()) {
191 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
192 InternalSwap(other);
193 } else {
194 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
195 }
196 }
197 void UnsafeArenaSwap(CreateSessionRequest* other) {
198 if (other == this) return;
199 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
200 InternalSwap(other);
201 }
202
203 // implements Message ----------------------------------------------
204
205 CreateSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
206 return CreateMaybeMessage<CreateSessionRequest>(arena);
207 }
208 CreateSessionRequest* New() const {
209 return New(nullptr);
210 }
211 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
212 void CopyFrom(const CreateSessionRequest& from);
213 void MergeFrom(const CreateSessionRequest& from);
214 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
215 bool IsInitialized() const final;
216
217 size_t ByteSizeLong() const final;
218 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
219 ::uint8_t* _InternalSerialize(
220 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
221 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
222
223 private:
224 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
225 void SharedDtor();
226 void SetCachedSize(int size) const;
227 void InternalSwap(CreateSessionRequest* other);
228
229 private:
230 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
231 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
232 return "tensorflow.CreateSessionRequest";
233 }
234 protected:
235 explicit CreateSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
236 bool is_message_owned = false);
237 public:
238
239 std::string GetTypeName() const final;
240
241 // nested types ----------------------------------------------------
242
243 // accessors -------------------------------------------------------
244
245 enum : int {
246 kTargetFieldNumber = 3,
247 kGraphDefFieldNumber = 1,
248 kConfigFieldNumber = 2,
249 };
250 // string target = 3;
251 void clear_target();
252 const std::string& target() const;
253 template <typename ArgT0 = const std::string&, typename... ArgT>
254 void set_target(ArgT0&& arg0, ArgT... args);
255 std::string* mutable_target();
256 PROTOBUF_NODISCARD std::string* release_target();
257 void set_allocated_target(std::string* target);
258 private:
259 const std::string& _internal_target() const;
260 inline PROTOBUF_ALWAYS_INLINE void _internal_set_target(const std::string& value);
261 std::string* _internal_mutable_target();
262 public:
263
264 // .tensorflow.GraphDef graph_def = 1;
265 bool has_graph_def() const;
266 private:
267 bool _internal_has_graph_def() const;
268 public:
269 void clear_graph_def();
270 const ::tensorflow::GraphDef& graph_def() const;
271 PROTOBUF_NODISCARD ::tensorflow::GraphDef* release_graph_def();
272 ::tensorflow::GraphDef* mutable_graph_def();
273 void set_allocated_graph_def(::tensorflow::GraphDef* graph_def);
274 private:
275 const ::tensorflow::GraphDef& _internal_graph_def() const;
276 ::tensorflow::GraphDef* _internal_mutable_graph_def();
277 public:
278 void unsafe_arena_set_allocated_graph_def(
279 ::tensorflow::GraphDef* graph_def);
280 ::tensorflow::GraphDef* unsafe_arena_release_graph_def();
281
282 // .tensorflow.ConfigProto config = 2;
283 bool has_config() const;
284 private:
285 bool _internal_has_config() const;
286 public:
287 void clear_config();
288 const ::tensorflow::ConfigProto& config() const;
289 PROTOBUF_NODISCARD ::tensorflow::ConfigProto* release_config();
290 ::tensorflow::ConfigProto* mutable_config();
291 void set_allocated_config(::tensorflow::ConfigProto* config);
292 private:
293 const ::tensorflow::ConfigProto& _internal_config() const;
294 ::tensorflow::ConfigProto* _internal_mutable_config();
295 public:
296 void unsafe_arena_set_allocated_config(
297 ::tensorflow::ConfigProto* config);
298 ::tensorflow::ConfigProto* unsafe_arena_release_config();
299
300 // @@protoc_insertion_point(class_scope:tensorflow.CreateSessionRequest)
301 private:
302 class _Internal;
303
304 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
305 typedef void InternalArenaConstructable_;
306 typedef void DestructorSkippable_;
307 struct Impl_ {
308 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr target_;
309 ::tensorflow::GraphDef* graph_def_;
310 ::tensorflow::ConfigProto* config_;
311 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
312 };
313 union { Impl_ _impl_; };
314 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
315 };
316 // -------------------------------------------------------------------
317
318 class CreateSessionResponse final :
319 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CreateSessionResponse) */ {
320 public:
CreateSessionResponse()321 inline CreateSessionResponse() : CreateSessionResponse(nullptr) {}
322 ~CreateSessionResponse() override;
323 explicit PROTOBUF_CONSTEXPR CreateSessionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
324
325 CreateSessionResponse(const CreateSessionResponse& from);
CreateSessionResponse(CreateSessionResponse && from)326 CreateSessionResponse(CreateSessionResponse&& from) noexcept
327 : CreateSessionResponse() {
328 *this = ::std::move(from);
329 }
330
331 inline CreateSessionResponse& operator=(const CreateSessionResponse& from) {
332 if (this == &from) return *this;
333 CopyFrom(from);
334 return *this;
335 }
336 inline CreateSessionResponse& operator=(CreateSessionResponse&& from) noexcept {
337 if (this == &from) return *this;
338 if (GetOwningArena() == from.GetOwningArena()
339 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
340 && GetOwningArena() != nullptr
341 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
342 ) {
343 InternalSwap(&from);
344 } else {
345 CopyFrom(from);
346 }
347 return *this;
348 }
349
default_instance()350 static const CreateSessionResponse& default_instance() {
351 return *internal_default_instance();
352 }
internal_default_instance()353 static inline const CreateSessionResponse* internal_default_instance() {
354 return reinterpret_cast<const CreateSessionResponse*>(
355 &_CreateSessionResponse_default_instance_);
356 }
357 static constexpr int kIndexInFileMessages =
358 1;
359
swap(CreateSessionResponse & a,CreateSessionResponse & b)360 friend void swap(CreateSessionResponse& a, CreateSessionResponse& b) {
361 a.Swap(&b);
362 }
Swap(CreateSessionResponse * other)363 inline void Swap(CreateSessionResponse* other) {
364 if (other == this) return;
365 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
366 if (GetOwningArena() != nullptr &&
367 GetOwningArena() == other->GetOwningArena()) {
368 #else // PROTOBUF_FORCE_COPY_IN_SWAP
369 if (GetOwningArena() == other->GetOwningArena()) {
370 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
371 InternalSwap(other);
372 } else {
373 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
374 }
375 }
376 void UnsafeArenaSwap(CreateSessionResponse* other) {
377 if (other == this) return;
378 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
379 InternalSwap(other);
380 }
381
382 // implements Message ----------------------------------------------
383
384 CreateSessionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
385 return CreateMaybeMessage<CreateSessionResponse>(arena);
386 }
387 CreateSessionResponse* New() const {
388 return New(nullptr);
389 }
390 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
391 void CopyFrom(const CreateSessionResponse& from);
392 void MergeFrom(const CreateSessionResponse& from);
393 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
394 bool IsInitialized() const final;
395
396 size_t ByteSizeLong() const final;
397 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
398 ::uint8_t* _InternalSerialize(
399 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
400 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
401
402 private:
403 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
404 void SharedDtor();
405 void SetCachedSize(int size) const;
406 void InternalSwap(CreateSessionResponse* other);
407
408 private:
409 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
410 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
411 return "tensorflow.CreateSessionResponse";
412 }
413 protected:
414 explicit CreateSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
415 bool is_message_owned = false);
416 public:
417
418 std::string GetTypeName() const final;
419
420 // nested types ----------------------------------------------------
421
422 // accessors -------------------------------------------------------
423
424 enum : int {
425 kSessionHandleFieldNumber = 1,
426 kGraphVersionFieldNumber = 2,
427 };
428 // string session_handle = 1;
429 void clear_session_handle();
430 const std::string& session_handle() const;
431 template <typename ArgT0 = const std::string&, typename... ArgT>
432 void set_session_handle(ArgT0&& arg0, ArgT... args);
433 std::string* mutable_session_handle();
434 PROTOBUF_NODISCARD std::string* release_session_handle();
435 void set_allocated_session_handle(std::string* session_handle);
436 private:
437 const std::string& _internal_session_handle() const;
438 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
439 std::string* _internal_mutable_session_handle();
440 public:
441
442 // int64 graph_version = 2;
443 void clear_graph_version();
444 ::int64_t graph_version() const;
445 void set_graph_version(::int64_t value);
446 private:
447 ::int64_t _internal_graph_version() const;
448 void _internal_set_graph_version(::int64_t value);
449 public:
450
451 // @@protoc_insertion_point(class_scope:tensorflow.CreateSessionResponse)
452 private:
453 class _Internal;
454
455 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
456 typedef void InternalArenaConstructable_;
457 typedef void DestructorSkippable_;
458 struct Impl_ {
459 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
460 ::int64_t graph_version_;
461 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
462 };
463 union { Impl_ _impl_; };
464 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
465 };
466 // -------------------------------------------------------------------
467
468 class ExtendSessionRequest final :
469 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ExtendSessionRequest) */ {
470 public:
ExtendSessionRequest()471 inline ExtendSessionRequest() : ExtendSessionRequest(nullptr) {}
472 ~ExtendSessionRequest() override;
473 explicit PROTOBUF_CONSTEXPR ExtendSessionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
474
475 ExtendSessionRequest(const ExtendSessionRequest& from);
ExtendSessionRequest(ExtendSessionRequest && from)476 ExtendSessionRequest(ExtendSessionRequest&& from) noexcept
477 : ExtendSessionRequest() {
478 *this = ::std::move(from);
479 }
480
481 inline ExtendSessionRequest& operator=(const ExtendSessionRequest& from) {
482 if (this == &from) return *this;
483 CopyFrom(from);
484 return *this;
485 }
486 inline ExtendSessionRequest& operator=(ExtendSessionRequest&& from) noexcept {
487 if (this == &from) return *this;
488 if (GetOwningArena() == from.GetOwningArena()
489 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
490 && GetOwningArena() != nullptr
491 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
492 ) {
493 InternalSwap(&from);
494 } else {
495 CopyFrom(from);
496 }
497 return *this;
498 }
499
default_instance()500 static const ExtendSessionRequest& default_instance() {
501 return *internal_default_instance();
502 }
internal_default_instance()503 static inline const ExtendSessionRequest* internal_default_instance() {
504 return reinterpret_cast<const ExtendSessionRequest*>(
505 &_ExtendSessionRequest_default_instance_);
506 }
507 static constexpr int kIndexInFileMessages =
508 2;
509
swap(ExtendSessionRequest & a,ExtendSessionRequest & b)510 friend void swap(ExtendSessionRequest& a, ExtendSessionRequest& b) {
511 a.Swap(&b);
512 }
Swap(ExtendSessionRequest * other)513 inline void Swap(ExtendSessionRequest* other) {
514 if (other == this) return;
515 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
516 if (GetOwningArena() != nullptr &&
517 GetOwningArena() == other->GetOwningArena()) {
518 #else // PROTOBUF_FORCE_COPY_IN_SWAP
519 if (GetOwningArena() == other->GetOwningArena()) {
520 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
521 InternalSwap(other);
522 } else {
523 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
524 }
525 }
526 void UnsafeArenaSwap(ExtendSessionRequest* other) {
527 if (other == this) return;
528 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
529 InternalSwap(other);
530 }
531
532 // implements Message ----------------------------------------------
533
534 ExtendSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
535 return CreateMaybeMessage<ExtendSessionRequest>(arena);
536 }
537 ExtendSessionRequest* New() const {
538 return New(nullptr);
539 }
540 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
541 void CopyFrom(const ExtendSessionRequest& from);
542 void MergeFrom(const ExtendSessionRequest& from);
543 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
544 bool IsInitialized() const final;
545
546 size_t ByteSizeLong() const final;
547 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
548 ::uint8_t* _InternalSerialize(
549 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
550 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
551
552 private:
553 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
554 void SharedDtor();
555 void SetCachedSize(int size) const;
556 void InternalSwap(ExtendSessionRequest* other);
557
558 private:
559 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
560 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
561 return "tensorflow.ExtendSessionRequest";
562 }
563 protected:
564 explicit ExtendSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
565 bool is_message_owned = false);
566 public:
567
568 std::string GetTypeName() const final;
569
570 // nested types ----------------------------------------------------
571
572 // accessors -------------------------------------------------------
573
574 enum : int {
575 kSessionHandleFieldNumber = 1,
576 kGraphDefFieldNumber = 2,
577 kCurrentGraphVersionFieldNumber = 3,
578 };
579 // string session_handle = 1;
580 void clear_session_handle();
581 const std::string& session_handle() const;
582 template <typename ArgT0 = const std::string&, typename... ArgT>
583 void set_session_handle(ArgT0&& arg0, ArgT... args);
584 std::string* mutable_session_handle();
585 PROTOBUF_NODISCARD std::string* release_session_handle();
586 void set_allocated_session_handle(std::string* session_handle);
587 private:
588 const std::string& _internal_session_handle() const;
589 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
590 std::string* _internal_mutable_session_handle();
591 public:
592
593 // .tensorflow.GraphDef graph_def = 2;
594 bool has_graph_def() const;
595 private:
596 bool _internal_has_graph_def() const;
597 public:
598 void clear_graph_def();
599 const ::tensorflow::GraphDef& graph_def() const;
600 PROTOBUF_NODISCARD ::tensorflow::GraphDef* release_graph_def();
601 ::tensorflow::GraphDef* mutable_graph_def();
602 void set_allocated_graph_def(::tensorflow::GraphDef* graph_def);
603 private:
604 const ::tensorflow::GraphDef& _internal_graph_def() const;
605 ::tensorflow::GraphDef* _internal_mutable_graph_def();
606 public:
607 void unsafe_arena_set_allocated_graph_def(
608 ::tensorflow::GraphDef* graph_def);
609 ::tensorflow::GraphDef* unsafe_arena_release_graph_def();
610
611 // int64 current_graph_version = 3;
612 void clear_current_graph_version();
613 ::int64_t current_graph_version() const;
614 void set_current_graph_version(::int64_t value);
615 private:
616 ::int64_t _internal_current_graph_version() const;
617 void _internal_set_current_graph_version(::int64_t value);
618 public:
619
620 // @@protoc_insertion_point(class_scope:tensorflow.ExtendSessionRequest)
621 private:
622 class _Internal;
623
624 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
625 typedef void InternalArenaConstructable_;
626 typedef void DestructorSkippable_;
627 struct Impl_ {
628 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
629 ::tensorflow::GraphDef* graph_def_;
630 ::int64_t current_graph_version_;
631 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
632 };
633 union { Impl_ _impl_; };
634 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
635 };
636 // -------------------------------------------------------------------
637
638 class ExtendSessionResponse final :
639 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ExtendSessionResponse) */ {
640 public:
ExtendSessionResponse()641 inline ExtendSessionResponse() : ExtendSessionResponse(nullptr) {}
642 ~ExtendSessionResponse() override;
643 explicit PROTOBUF_CONSTEXPR ExtendSessionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
644
645 ExtendSessionResponse(const ExtendSessionResponse& from);
ExtendSessionResponse(ExtendSessionResponse && from)646 ExtendSessionResponse(ExtendSessionResponse&& from) noexcept
647 : ExtendSessionResponse() {
648 *this = ::std::move(from);
649 }
650
651 inline ExtendSessionResponse& operator=(const ExtendSessionResponse& from) {
652 if (this == &from) return *this;
653 CopyFrom(from);
654 return *this;
655 }
656 inline ExtendSessionResponse& operator=(ExtendSessionResponse&& from) noexcept {
657 if (this == &from) return *this;
658 if (GetOwningArena() == from.GetOwningArena()
659 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
660 && GetOwningArena() != nullptr
661 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
662 ) {
663 InternalSwap(&from);
664 } else {
665 CopyFrom(from);
666 }
667 return *this;
668 }
669
default_instance()670 static const ExtendSessionResponse& default_instance() {
671 return *internal_default_instance();
672 }
internal_default_instance()673 static inline const ExtendSessionResponse* internal_default_instance() {
674 return reinterpret_cast<const ExtendSessionResponse*>(
675 &_ExtendSessionResponse_default_instance_);
676 }
677 static constexpr int kIndexInFileMessages =
678 3;
679
swap(ExtendSessionResponse & a,ExtendSessionResponse & b)680 friend void swap(ExtendSessionResponse& a, ExtendSessionResponse& b) {
681 a.Swap(&b);
682 }
Swap(ExtendSessionResponse * other)683 inline void Swap(ExtendSessionResponse* other) {
684 if (other == this) return;
685 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
686 if (GetOwningArena() != nullptr &&
687 GetOwningArena() == other->GetOwningArena()) {
688 #else // PROTOBUF_FORCE_COPY_IN_SWAP
689 if (GetOwningArena() == other->GetOwningArena()) {
690 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
691 InternalSwap(other);
692 } else {
693 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
694 }
695 }
696 void UnsafeArenaSwap(ExtendSessionResponse* other) {
697 if (other == this) return;
698 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
699 InternalSwap(other);
700 }
701
702 // implements Message ----------------------------------------------
703
704 ExtendSessionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
705 return CreateMaybeMessage<ExtendSessionResponse>(arena);
706 }
707 ExtendSessionResponse* New() const {
708 return New(nullptr);
709 }
710 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
711 void CopyFrom(const ExtendSessionResponse& from);
712 void MergeFrom(const ExtendSessionResponse& from);
713 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
714 bool IsInitialized() const final;
715
716 size_t ByteSizeLong() const final;
717 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
718 ::uint8_t* _InternalSerialize(
719 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
720 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
721
722 private:
723 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
724 void SharedDtor();
725 void SetCachedSize(int size) const;
726 void InternalSwap(ExtendSessionResponse* other);
727
728 private:
729 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
730 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
731 return "tensorflow.ExtendSessionResponse";
732 }
733 protected:
734 explicit ExtendSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
735 bool is_message_owned = false);
736 public:
737
738 std::string GetTypeName() const final;
739
740 // nested types ----------------------------------------------------
741
742 // accessors -------------------------------------------------------
743
744 enum : int {
745 kNewGraphVersionFieldNumber = 4,
746 };
747 // int64 new_graph_version = 4;
748 void clear_new_graph_version();
749 ::int64_t new_graph_version() const;
750 void set_new_graph_version(::int64_t value);
751 private:
752 ::int64_t _internal_new_graph_version() const;
753 void _internal_set_new_graph_version(::int64_t value);
754 public:
755
756 // @@protoc_insertion_point(class_scope:tensorflow.ExtendSessionResponse)
757 private:
758 class _Internal;
759
760 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
761 typedef void InternalArenaConstructable_;
762 typedef void DestructorSkippable_;
763 struct Impl_ {
764 ::int64_t new_graph_version_;
765 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
766 };
767 union { Impl_ _impl_; };
768 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
769 };
770 // -------------------------------------------------------------------
771
772 class RunStepRequest final :
773 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RunStepRequest) */ {
774 public:
RunStepRequest()775 inline RunStepRequest() : RunStepRequest(nullptr) {}
776 ~RunStepRequest() override;
777 explicit PROTOBUF_CONSTEXPR RunStepRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
778
779 RunStepRequest(const RunStepRequest& from);
RunStepRequest(RunStepRequest && from)780 RunStepRequest(RunStepRequest&& from) noexcept
781 : RunStepRequest() {
782 *this = ::std::move(from);
783 }
784
785 inline RunStepRequest& operator=(const RunStepRequest& from) {
786 if (this == &from) return *this;
787 CopyFrom(from);
788 return *this;
789 }
790 inline RunStepRequest& operator=(RunStepRequest&& from) noexcept {
791 if (this == &from) return *this;
792 if (GetOwningArena() == from.GetOwningArena()
793 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
794 && GetOwningArena() != nullptr
795 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
796 ) {
797 InternalSwap(&from);
798 } else {
799 CopyFrom(from);
800 }
801 return *this;
802 }
803
default_instance()804 static const RunStepRequest& default_instance() {
805 return *internal_default_instance();
806 }
internal_default_instance()807 static inline const RunStepRequest* internal_default_instance() {
808 return reinterpret_cast<const RunStepRequest*>(
809 &_RunStepRequest_default_instance_);
810 }
811 static constexpr int kIndexInFileMessages =
812 4;
813
swap(RunStepRequest & a,RunStepRequest & b)814 friend void swap(RunStepRequest& a, RunStepRequest& b) {
815 a.Swap(&b);
816 }
Swap(RunStepRequest * other)817 inline void Swap(RunStepRequest* other) {
818 if (other == this) return;
819 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
820 if (GetOwningArena() != nullptr &&
821 GetOwningArena() == other->GetOwningArena()) {
822 #else // PROTOBUF_FORCE_COPY_IN_SWAP
823 if (GetOwningArena() == other->GetOwningArena()) {
824 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
825 InternalSwap(other);
826 } else {
827 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
828 }
829 }
830 void UnsafeArenaSwap(RunStepRequest* other) {
831 if (other == this) return;
832 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
833 InternalSwap(other);
834 }
835
836 // implements Message ----------------------------------------------
837
838 RunStepRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
839 return CreateMaybeMessage<RunStepRequest>(arena);
840 }
841 RunStepRequest* New() const {
842 return New(nullptr);
843 }
844 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
845 void CopyFrom(const RunStepRequest& from);
846 void MergeFrom(const RunStepRequest& from);
847 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
848 bool IsInitialized() const final;
849
850 size_t ByteSizeLong() const final;
851 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
852 ::uint8_t* _InternalSerialize(
853 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
854 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
855
856 private:
857 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
858 void SharedDtor();
859 void SetCachedSize(int size) const;
860 void InternalSwap(RunStepRequest* other);
861
862 private:
863 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
864 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
865 return "tensorflow.RunStepRequest";
866 }
867 protected:
868 explicit RunStepRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
869 bool is_message_owned = false);
870 public:
871
872 std::string GetTypeName() const final;
873
874 // nested types ----------------------------------------------------
875
876 // accessors -------------------------------------------------------
877
878 enum : int {
879 kFeedFieldNumber = 2,
880 kFetchFieldNumber = 3,
881 kTargetFieldNumber = 4,
882 kSessionHandleFieldNumber = 1,
883 kPartialRunHandleFieldNumber = 6,
884 kOptionsFieldNumber = 5,
885 kRequestIdFieldNumber = 8,
886 kStoreErrorsInResponseBodyFieldNumber = 7,
887 };
888 // repeated .tensorflow.NamedTensorProto feed = 2;
889 int feed_size() const;
890 private:
891 int _internal_feed_size() const;
892 public:
893 void clear_feed();
894 ::tensorflow::NamedTensorProto* mutable_feed(int index);
895 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
896 mutable_feed();
897 private:
898 const ::tensorflow::NamedTensorProto& _internal_feed(int index) const;
899 ::tensorflow::NamedTensorProto* _internal_add_feed();
900 public:
901 const ::tensorflow::NamedTensorProto& feed(int index) const;
902 ::tensorflow::NamedTensorProto* add_feed();
903 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
904 feed() const;
905
906 // repeated string fetch = 3;
907 int fetch_size() const;
908 private:
909 int _internal_fetch_size() const;
910 public:
911 void clear_fetch();
912 const std::string& fetch(int index) const;
913 std::string* mutable_fetch(int index);
914 void set_fetch(int index, const std::string& value);
915 void set_fetch(int index, std::string&& value);
916 void set_fetch(int index, const char* value);
917 void set_fetch(int index, const char* value, size_t size);
918 std::string* add_fetch();
919 void add_fetch(const std::string& value);
920 void add_fetch(std::string&& value);
921 void add_fetch(const char* value);
922 void add_fetch(const char* value, size_t size);
923 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& fetch() const;
924 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_fetch();
925 private:
926 const std::string& _internal_fetch(int index) const;
927 std::string* _internal_add_fetch();
928 public:
929
930 // repeated string target = 4;
931 int target_size() const;
932 private:
933 int _internal_target_size() const;
934 public:
935 void clear_target();
936 const std::string& target(int index) const;
937 std::string* mutable_target(int index);
938 void set_target(int index, const std::string& value);
939 void set_target(int index, std::string&& value);
940 void set_target(int index, const char* value);
941 void set_target(int index, const char* value, size_t size);
942 std::string* add_target();
943 void add_target(const std::string& value);
944 void add_target(std::string&& value);
945 void add_target(const char* value);
946 void add_target(const char* value, size_t size);
947 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& target() const;
948 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_target();
949 private:
950 const std::string& _internal_target(int index) const;
951 std::string* _internal_add_target();
952 public:
953
954 // string session_handle = 1;
955 void clear_session_handle();
956 const std::string& session_handle() const;
957 template <typename ArgT0 = const std::string&, typename... ArgT>
958 void set_session_handle(ArgT0&& arg0, ArgT... args);
959 std::string* mutable_session_handle();
960 PROTOBUF_NODISCARD std::string* release_session_handle();
961 void set_allocated_session_handle(std::string* session_handle);
962 private:
963 const std::string& _internal_session_handle() const;
964 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
965 std::string* _internal_mutable_session_handle();
966 public:
967
968 // string partial_run_handle = 6;
969 void clear_partial_run_handle();
970 const std::string& partial_run_handle() const;
971 template <typename ArgT0 = const std::string&, typename... ArgT>
972 void set_partial_run_handle(ArgT0&& arg0, ArgT... args);
973 std::string* mutable_partial_run_handle();
974 PROTOBUF_NODISCARD std::string* release_partial_run_handle();
975 void set_allocated_partial_run_handle(std::string* partial_run_handle);
976 private:
977 const std::string& _internal_partial_run_handle() const;
978 inline PROTOBUF_ALWAYS_INLINE void _internal_set_partial_run_handle(const std::string& value);
979 std::string* _internal_mutable_partial_run_handle();
980 public:
981
982 // .tensorflow.RunOptions options = 5;
983 bool has_options() const;
984 private:
985 bool _internal_has_options() const;
986 public:
987 void clear_options();
988 const ::tensorflow::RunOptions& options() const;
989 PROTOBUF_NODISCARD ::tensorflow::RunOptions* release_options();
990 ::tensorflow::RunOptions* mutable_options();
991 void set_allocated_options(::tensorflow::RunOptions* options);
992 private:
993 const ::tensorflow::RunOptions& _internal_options() const;
994 ::tensorflow::RunOptions* _internal_mutable_options();
995 public:
996 void unsafe_arena_set_allocated_options(
997 ::tensorflow::RunOptions* options);
998 ::tensorflow::RunOptions* unsafe_arena_release_options();
999
1000 // int64 request_id = 8;
1001 void clear_request_id();
1002 ::int64_t request_id() const;
1003 void set_request_id(::int64_t value);
1004 private:
1005 ::int64_t _internal_request_id() const;
1006 void _internal_set_request_id(::int64_t value);
1007 public:
1008
1009 // bool store_errors_in_response_body = 7;
1010 void clear_store_errors_in_response_body();
1011 bool store_errors_in_response_body() const;
1012 void set_store_errors_in_response_body(bool value);
1013 private:
1014 bool _internal_store_errors_in_response_body() const;
1015 void _internal_set_store_errors_in_response_body(bool value);
1016 public:
1017
1018 // @@protoc_insertion_point(class_scope:tensorflow.RunStepRequest)
1019 private:
1020 class _Internal;
1021
1022 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1023 typedef void InternalArenaConstructable_;
1024 typedef void DestructorSkippable_;
1025 struct Impl_ {
1026 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto > feed_;
1027 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> fetch_;
1028 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> target_;
1029 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
1030 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partial_run_handle_;
1031 ::tensorflow::RunOptions* options_;
1032 ::int64_t request_id_;
1033 bool store_errors_in_response_body_;
1034 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1035 };
1036 union { Impl_ _impl_; };
1037 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
1038 };
1039 // -------------------------------------------------------------------
1040
1041 class RunStepResponse final :
1042 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RunStepResponse) */ {
1043 public:
RunStepResponse()1044 inline RunStepResponse() : RunStepResponse(nullptr) {}
1045 ~RunStepResponse() override;
1046 explicit PROTOBUF_CONSTEXPR RunStepResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1047
1048 RunStepResponse(const RunStepResponse& from);
RunStepResponse(RunStepResponse && from)1049 RunStepResponse(RunStepResponse&& from) noexcept
1050 : RunStepResponse() {
1051 *this = ::std::move(from);
1052 }
1053
1054 inline RunStepResponse& operator=(const RunStepResponse& from) {
1055 if (this == &from) return *this;
1056 CopyFrom(from);
1057 return *this;
1058 }
1059 inline RunStepResponse& operator=(RunStepResponse&& from) noexcept {
1060 if (this == &from) return *this;
1061 if (GetOwningArena() == from.GetOwningArena()
1062 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1063 && GetOwningArena() != nullptr
1064 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1065 ) {
1066 InternalSwap(&from);
1067 } else {
1068 CopyFrom(from);
1069 }
1070 return *this;
1071 }
1072
default_instance()1073 static const RunStepResponse& default_instance() {
1074 return *internal_default_instance();
1075 }
internal_default_instance()1076 static inline const RunStepResponse* internal_default_instance() {
1077 return reinterpret_cast<const RunStepResponse*>(
1078 &_RunStepResponse_default_instance_);
1079 }
1080 static constexpr int kIndexInFileMessages =
1081 5;
1082
swap(RunStepResponse & a,RunStepResponse & b)1083 friend void swap(RunStepResponse& a, RunStepResponse& b) {
1084 a.Swap(&b);
1085 }
Swap(RunStepResponse * other)1086 inline void Swap(RunStepResponse* other) {
1087 if (other == this) return;
1088 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1089 if (GetOwningArena() != nullptr &&
1090 GetOwningArena() == other->GetOwningArena()) {
1091 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1092 if (GetOwningArena() == other->GetOwningArena()) {
1093 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1094 InternalSwap(other);
1095 } else {
1096 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1097 }
1098 }
1099 void UnsafeArenaSwap(RunStepResponse* other) {
1100 if (other == this) return;
1101 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1102 InternalSwap(other);
1103 }
1104
1105 // implements Message ----------------------------------------------
1106
1107 RunStepResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1108 return CreateMaybeMessage<RunStepResponse>(arena);
1109 }
1110 RunStepResponse* New() const {
1111 return New(nullptr);
1112 }
1113 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1114 void CopyFrom(const RunStepResponse& from);
1115 void MergeFrom(const RunStepResponse& from);
1116 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1117 bool IsInitialized() const final;
1118
1119 size_t ByteSizeLong() const final;
1120 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1121 ::uint8_t* _InternalSerialize(
1122 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1123 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1124
1125 private:
1126 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1127 void SharedDtor();
1128 void SetCachedSize(int size) const;
1129 void InternalSwap(RunStepResponse* other);
1130
1131 private:
1132 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1133 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1134 return "tensorflow.RunStepResponse";
1135 }
1136 protected:
1137 explicit RunStepResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1138 bool is_message_owned = false);
1139 public:
1140
1141 std::string GetTypeName() const final;
1142
1143 // nested types ----------------------------------------------------
1144
1145 // accessors -------------------------------------------------------
1146
1147 enum : int {
1148 kTensorFieldNumber = 1,
1149 kStatusErrorMessageFieldNumber = 4,
1150 kMetadataFieldNumber = 2,
1151 kStatusCodeFieldNumber = 3,
1152 };
1153 // repeated .tensorflow.NamedTensorProto tensor = 1;
1154 int tensor_size() const;
1155 private:
1156 int _internal_tensor_size() const;
1157 public:
1158 void clear_tensor();
1159 ::tensorflow::NamedTensorProto* mutable_tensor(int index);
1160 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
1161 mutable_tensor();
1162 private:
1163 const ::tensorflow::NamedTensorProto& _internal_tensor(int index) const;
1164 ::tensorflow::NamedTensorProto* _internal_add_tensor();
1165 public:
1166 const ::tensorflow::NamedTensorProto& tensor(int index) const;
1167 ::tensorflow::NamedTensorProto* add_tensor();
1168 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
1169 tensor() const;
1170
1171 // string status_error_message = 4;
1172 void clear_status_error_message();
1173 const std::string& status_error_message() const;
1174 template <typename ArgT0 = const std::string&, typename... ArgT>
1175 void set_status_error_message(ArgT0&& arg0, ArgT... args);
1176 std::string* mutable_status_error_message();
1177 PROTOBUF_NODISCARD std::string* release_status_error_message();
1178 void set_allocated_status_error_message(std::string* status_error_message);
1179 private:
1180 const std::string& _internal_status_error_message() const;
1181 inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_error_message(const std::string& value);
1182 std::string* _internal_mutable_status_error_message();
1183 public:
1184
1185 // .tensorflow.RunMetadata metadata = 2;
1186 bool has_metadata() const;
1187 private:
1188 bool _internal_has_metadata() const;
1189 public:
1190 void clear_metadata();
1191 const ::tensorflow::RunMetadata& metadata() const;
1192 PROTOBUF_NODISCARD ::tensorflow::RunMetadata* release_metadata();
1193 ::tensorflow::RunMetadata* mutable_metadata();
1194 void set_allocated_metadata(::tensorflow::RunMetadata* metadata);
1195 private:
1196 const ::tensorflow::RunMetadata& _internal_metadata() const;
1197 ::tensorflow::RunMetadata* _internal_mutable_metadata();
1198 public:
1199 void unsafe_arena_set_allocated_metadata(
1200 ::tensorflow::RunMetadata* metadata);
1201 ::tensorflow::RunMetadata* unsafe_arena_release_metadata();
1202
1203 // .tensorflow.error.Code status_code = 3;
1204 void clear_status_code();
1205 ::tensorflow::error::Code status_code() const;
1206 void set_status_code(::tensorflow::error::Code value);
1207 private:
1208 ::tensorflow::error::Code _internal_status_code() const;
1209 void _internal_set_status_code(::tensorflow::error::Code value);
1210 public:
1211
1212 // @@protoc_insertion_point(class_scope:tensorflow.RunStepResponse)
1213 private:
1214 class _Internal;
1215
1216 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1217 typedef void InternalArenaConstructable_;
1218 typedef void DestructorSkippable_;
1219 struct Impl_ {
1220 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto > tensor_;
1221 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_error_message_;
1222 ::tensorflow::RunMetadata* metadata_;
1223 int status_code_;
1224 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1225 };
1226 union { Impl_ _impl_; };
1227 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
1228 };
1229 // -------------------------------------------------------------------
1230
1231 class PartialRunSetupRequest final :
1232 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.PartialRunSetupRequest) */ {
1233 public:
PartialRunSetupRequest()1234 inline PartialRunSetupRequest() : PartialRunSetupRequest(nullptr) {}
1235 ~PartialRunSetupRequest() override;
1236 explicit PROTOBUF_CONSTEXPR PartialRunSetupRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1237
1238 PartialRunSetupRequest(const PartialRunSetupRequest& from);
PartialRunSetupRequest(PartialRunSetupRequest && from)1239 PartialRunSetupRequest(PartialRunSetupRequest&& from) noexcept
1240 : PartialRunSetupRequest() {
1241 *this = ::std::move(from);
1242 }
1243
1244 inline PartialRunSetupRequest& operator=(const PartialRunSetupRequest& from) {
1245 if (this == &from) return *this;
1246 CopyFrom(from);
1247 return *this;
1248 }
1249 inline PartialRunSetupRequest& operator=(PartialRunSetupRequest&& from) noexcept {
1250 if (this == &from) return *this;
1251 if (GetOwningArena() == from.GetOwningArena()
1252 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1253 && GetOwningArena() != nullptr
1254 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1255 ) {
1256 InternalSwap(&from);
1257 } else {
1258 CopyFrom(from);
1259 }
1260 return *this;
1261 }
1262
default_instance()1263 static const PartialRunSetupRequest& default_instance() {
1264 return *internal_default_instance();
1265 }
internal_default_instance()1266 static inline const PartialRunSetupRequest* internal_default_instance() {
1267 return reinterpret_cast<const PartialRunSetupRequest*>(
1268 &_PartialRunSetupRequest_default_instance_);
1269 }
1270 static constexpr int kIndexInFileMessages =
1271 6;
1272
swap(PartialRunSetupRequest & a,PartialRunSetupRequest & b)1273 friend void swap(PartialRunSetupRequest& a, PartialRunSetupRequest& b) {
1274 a.Swap(&b);
1275 }
Swap(PartialRunSetupRequest * other)1276 inline void Swap(PartialRunSetupRequest* other) {
1277 if (other == this) return;
1278 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1279 if (GetOwningArena() != nullptr &&
1280 GetOwningArena() == other->GetOwningArena()) {
1281 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1282 if (GetOwningArena() == other->GetOwningArena()) {
1283 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1284 InternalSwap(other);
1285 } else {
1286 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1287 }
1288 }
1289 void UnsafeArenaSwap(PartialRunSetupRequest* other) {
1290 if (other == this) return;
1291 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1292 InternalSwap(other);
1293 }
1294
1295 // implements Message ----------------------------------------------
1296
1297 PartialRunSetupRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1298 return CreateMaybeMessage<PartialRunSetupRequest>(arena);
1299 }
1300 PartialRunSetupRequest* New() const {
1301 return New(nullptr);
1302 }
1303 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1304 void CopyFrom(const PartialRunSetupRequest& from);
1305 void MergeFrom(const PartialRunSetupRequest& from);
1306 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1307 bool IsInitialized() const final;
1308
1309 size_t ByteSizeLong() const final;
1310 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1311 ::uint8_t* _InternalSerialize(
1312 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1313 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1314
1315 private:
1316 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1317 void SharedDtor();
1318 void SetCachedSize(int size) const;
1319 void InternalSwap(PartialRunSetupRequest* other);
1320
1321 private:
1322 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1323 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1324 return "tensorflow.PartialRunSetupRequest";
1325 }
1326 protected:
1327 explicit PartialRunSetupRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1328 bool is_message_owned = false);
1329 public:
1330
1331 std::string GetTypeName() const final;
1332
1333 // nested types ----------------------------------------------------
1334
1335 // accessors -------------------------------------------------------
1336
1337 enum : int {
1338 kFeedFieldNumber = 2,
1339 kFetchFieldNumber = 3,
1340 kTargetFieldNumber = 4,
1341 kSessionHandleFieldNumber = 1,
1342 kRequestIdFieldNumber = 5,
1343 };
1344 // repeated string feed = 2;
1345 int feed_size() const;
1346 private:
1347 int _internal_feed_size() const;
1348 public:
1349 void clear_feed();
1350 const std::string& feed(int index) const;
1351 std::string* mutable_feed(int index);
1352 void set_feed(int index, const std::string& value);
1353 void set_feed(int index, std::string&& value);
1354 void set_feed(int index, const char* value);
1355 void set_feed(int index, const char* value, size_t size);
1356 std::string* add_feed();
1357 void add_feed(const std::string& value);
1358 void add_feed(std::string&& value);
1359 void add_feed(const char* value);
1360 void add_feed(const char* value, size_t size);
1361 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& feed() const;
1362 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_feed();
1363 private:
1364 const std::string& _internal_feed(int index) const;
1365 std::string* _internal_add_feed();
1366 public:
1367
1368 // repeated string fetch = 3;
1369 int fetch_size() const;
1370 private:
1371 int _internal_fetch_size() const;
1372 public:
1373 void clear_fetch();
1374 const std::string& fetch(int index) const;
1375 std::string* mutable_fetch(int index);
1376 void set_fetch(int index, const std::string& value);
1377 void set_fetch(int index, std::string&& value);
1378 void set_fetch(int index, const char* value);
1379 void set_fetch(int index, const char* value, size_t size);
1380 std::string* add_fetch();
1381 void add_fetch(const std::string& value);
1382 void add_fetch(std::string&& value);
1383 void add_fetch(const char* value);
1384 void add_fetch(const char* value, size_t size);
1385 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& fetch() const;
1386 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_fetch();
1387 private:
1388 const std::string& _internal_fetch(int index) const;
1389 std::string* _internal_add_fetch();
1390 public:
1391
1392 // repeated string target = 4;
1393 int target_size() const;
1394 private:
1395 int _internal_target_size() const;
1396 public:
1397 void clear_target();
1398 const std::string& target(int index) const;
1399 std::string* mutable_target(int index);
1400 void set_target(int index, const std::string& value);
1401 void set_target(int index, std::string&& value);
1402 void set_target(int index, const char* value);
1403 void set_target(int index, const char* value, size_t size);
1404 std::string* add_target();
1405 void add_target(const std::string& value);
1406 void add_target(std::string&& value);
1407 void add_target(const char* value);
1408 void add_target(const char* value, size_t size);
1409 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& target() const;
1410 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_target();
1411 private:
1412 const std::string& _internal_target(int index) const;
1413 std::string* _internal_add_target();
1414 public:
1415
1416 // string session_handle = 1;
1417 void clear_session_handle();
1418 const std::string& session_handle() const;
1419 template <typename ArgT0 = const std::string&, typename... ArgT>
1420 void set_session_handle(ArgT0&& arg0, ArgT... args);
1421 std::string* mutable_session_handle();
1422 PROTOBUF_NODISCARD std::string* release_session_handle();
1423 void set_allocated_session_handle(std::string* session_handle);
1424 private:
1425 const std::string& _internal_session_handle() const;
1426 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
1427 std::string* _internal_mutable_session_handle();
1428 public:
1429
1430 // int64 request_id = 5;
1431 void clear_request_id();
1432 ::int64_t request_id() const;
1433 void set_request_id(::int64_t value);
1434 private:
1435 ::int64_t _internal_request_id() const;
1436 void _internal_set_request_id(::int64_t value);
1437 public:
1438
1439 // @@protoc_insertion_point(class_scope:tensorflow.PartialRunSetupRequest)
1440 private:
1441 class _Internal;
1442
1443 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1444 typedef void InternalArenaConstructable_;
1445 typedef void DestructorSkippable_;
1446 struct Impl_ {
1447 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> feed_;
1448 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> fetch_;
1449 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> target_;
1450 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
1451 ::int64_t request_id_;
1452 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1453 };
1454 union { Impl_ _impl_; };
1455 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
1456 };
1457 // -------------------------------------------------------------------
1458
1459 class PartialRunSetupResponse final :
1460 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.PartialRunSetupResponse) */ {
1461 public:
PartialRunSetupResponse()1462 inline PartialRunSetupResponse() : PartialRunSetupResponse(nullptr) {}
1463 ~PartialRunSetupResponse() override;
1464 explicit PROTOBUF_CONSTEXPR PartialRunSetupResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1465
1466 PartialRunSetupResponse(const PartialRunSetupResponse& from);
PartialRunSetupResponse(PartialRunSetupResponse && from)1467 PartialRunSetupResponse(PartialRunSetupResponse&& from) noexcept
1468 : PartialRunSetupResponse() {
1469 *this = ::std::move(from);
1470 }
1471
1472 inline PartialRunSetupResponse& operator=(const PartialRunSetupResponse& from) {
1473 if (this == &from) return *this;
1474 CopyFrom(from);
1475 return *this;
1476 }
1477 inline PartialRunSetupResponse& operator=(PartialRunSetupResponse&& from) noexcept {
1478 if (this == &from) return *this;
1479 if (GetOwningArena() == from.GetOwningArena()
1480 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1481 && GetOwningArena() != nullptr
1482 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1483 ) {
1484 InternalSwap(&from);
1485 } else {
1486 CopyFrom(from);
1487 }
1488 return *this;
1489 }
1490
default_instance()1491 static const PartialRunSetupResponse& default_instance() {
1492 return *internal_default_instance();
1493 }
internal_default_instance()1494 static inline const PartialRunSetupResponse* internal_default_instance() {
1495 return reinterpret_cast<const PartialRunSetupResponse*>(
1496 &_PartialRunSetupResponse_default_instance_);
1497 }
1498 static constexpr int kIndexInFileMessages =
1499 7;
1500
swap(PartialRunSetupResponse & a,PartialRunSetupResponse & b)1501 friend void swap(PartialRunSetupResponse& a, PartialRunSetupResponse& b) {
1502 a.Swap(&b);
1503 }
Swap(PartialRunSetupResponse * other)1504 inline void Swap(PartialRunSetupResponse* other) {
1505 if (other == this) return;
1506 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1507 if (GetOwningArena() != nullptr &&
1508 GetOwningArena() == other->GetOwningArena()) {
1509 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1510 if (GetOwningArena() == other->GetOwningArena()) {
1511 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1512 InternalSwap(other);
1513 } else {
1514 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1515 }
1516 }
1517 void UnsafeArenaSwap(PartialRunSetupResponse* other) {
1518 if (other == this) return;
1519 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1520 InternalSwap(other);
1521 }
1522
1523 // implements Message ----------------------------------------------
1524
1525 PartialRunSetupResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1526 return CreateMaybeMessage<PartialRunSetupResponse>(arena);
1527 }
1528 PartialRunSetupResponse* New() const {
1529 return New(nullptr);
1530 }
1531 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1532 void CopyFrom(const PartialRunSetupResponse& from);
1533 void MergeFrom(const PartialRunSetupResponse& from);
1534 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1535 bool IsInitialized() const final;
1536
1537 size_t ByteSizeLong() const final;
1538 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1539 ::uint8_t* _InternalSerialize(
1540 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1541 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1542
1543 private:
1544 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1545 void SharedDtor();
1546 void SetCachedSize(int size) const;
1547 void InternalSwap(PartialRunSetupResponse* other);
1548
1549 private:
1550 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1551 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1552 return "tensorflow.PartialRunSetupResponse";
1553 }
1554 protected:
1555 explicit PartialRunSetupResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1556 bool is_message_owned = false);
1557 public:
1558
1559 std::string GetTypeName() const final;
1560
1561 // nested types ----------------------------------------------------
1562
1563 // accessors -------------------------------------------------------
1564
1565 enum : int {
1566 kPartialRunHandleFieldNumber = 1,
1567 };
1568 // string partial_run_handle = 1;
1569 void clear_partial_run_handle();
1570 const std::string& partial_run_handle() const;
1571 template <typename ArgT0 = const std::string&, typename... ArgT>
1572 void set_partial_run_handle(ArgT0&& arg0, ArgT... args);
1573 std::string* mutable_partial_run_handle();
1574 PROTOBUF_NODISCARD std::string* release_partial_run_handle();
1575 void set_allocated_partial_run_handle(std::string* partial_run_handle);
1576 private:
1577 const std::string& _internal_partial_run_handle() const;
1578 inline PROTOBUF_ALWAYS_INLINE void _internal_set_partial_run_handle(const std::string& value);
1579 std::string* _internal_mutable_partial_run_handle();
1580 public:
1581
1582 // @@protoc_insertion_point(class_scope:tensorflow.PartialRunSetupResponse)
1583 private:
1584 class _Internal;
1585
1586 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1587 typedef void InternalArenaConstructable_;
1588 typedef void DestructorSkippable_;
1589 struct Impl_ {
1590 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr partial_run_handle_;
1591 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1592 };
1593 union { Impl_ _impl_; };
1594 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
1595 };
1596 // -------------------------------------------------------------------
1597
1598 class CloseSessionRequest final :
1599 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CloseSessionRequest) */ {
1600 public:
CloseSessionRequest()1601 inline CloseSessionRequest() : CloseSessionRequest(nullptr) {}
1602 ~CloseSessionRequest() override;
1603 explicit PROTOBUF_CONSTEXPR CloseSessionRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1604
1605 CloseSessionRequest(const CloseSessionRequest& from);
CloseSessionRequest(CloseSessionRequest && from)1606 CloseSessionRequest(CloseSessionRequest&& from) noexcept
1607 : CloseSessionRequest() {
1608 *this = ::std::move(from);
1609 }
1610
1611 inline CloseSessionRequest& operator=(const CloseSessionRequest& from) {
1612 if (this == &from) return *this;
1613 CopyFrom(from);
1614 return *this;
1615 }
1616 inline CloseSessionRequest& operator=(CloseSessionRequest&& from) noexcept {
1617 if (this == &from) return *this;
1618 if (GetOwningArena() == from.GetOwningArena()
1619 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1620 && GetOwningArena() != nullptr
1621 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1622 ) {
1623 InternalSwap(&from);
1624 } else {
1625 CopyFrom(from);
1626 }
1627 return *this;
1628 }
1629
default_instance()1630 static const CloseSessionRequest& default_instance() {
1631 return *internal_default_instance();
1632 }
internal_default_instance()1633 static inline const CloseSessionRequest* internal_default_instance() {
1634 return reinterpret_cast<const CloseSessionRequest*>(
1635 &_CloseSessionRequest_default_instance_);
1636 }
1637 static constexpr int kIndexInFileMessages =
1638 8;
1639
swap(CloseSessionRequest & a,CloseSessionRequest & b)1640 friend void swap(CloseSessionRequest& a, CloseSessionRequest& b) {
1641 a.Swap(&b);
1642 }
Swap(CloseSessionRequest * other)1643 inline void Swap(CloseSessionRequest* other) {
1644 if (other == this) return;
1645 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1646 if (GetOwningArena() != nullptr &&
1647 GetOwningArena() == other->GetOwningArena()) {
1648 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1649 if (GetOwningArena() == other->GetOwningArena()) {
1650 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1651 InternalSwap(other);
1652 } else {
1653 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1654 }
1655 }
1656 void UnsafeArenaSwap(CloseSessionRequest* other) {
1657 if (other == this) return;
1658 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1659 InternalSwap(other);
1660 }
1661
1662 // implements Message ----------------------------------------------
1663
1664 CloseSessionRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1665 return CreateMaybeMessage<CloseSessionRequest>(arena);
1666 }
1667 CloseSessionRequest* New() const {
1668 return New(nullptr);
1669 }
1670 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1671 void CopyFrom(const CloseSessionRequest& from);
1672 void MergeFrom(const CloseSessionRequest& from);
1673 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1674 bool IsInitialized() const final;
1675
1676 size_t ByteSizeLong() const final;
1677 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1678 ::uint8_t* _InternalSerialize(
1679 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1680 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1681
1682 private:
1683 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1684 void SharedDtor();
1685 void SetCachedSize(int size) const;
1686 void InternalSwap(CloseSessionRequest* other);
1687
1688 private:
1689 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1690 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1691 return "tensorflow.CloseSessionRequest";
1692 }
1693 protected:
1694 explicit CloseSessionRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1695 bool is_message_owned = false);
1696 public:
1697
1698 std::string GetTypeName() const final;
1699
1700 // nested types ----------------------------------------------------
1701
1702 // accessors -------------------------------------------------------
1703
1704 enum : int {
1705 kSessionHandleFieldNumber = 1,
1706 };
1707 // string session_handle = 1;
1708 void clear_session_handle();
1709 const std::string& session_handle() const;
1710 template <typename ArgT0 = const std::string&, typename... ArgT>
1711 void set_session_handle(ArgT0&& arg0, ArgT... args);
1712 std::string* mutable_session_handle();
1713 PROTOBUF_NODISCARD std::string* release_session_handle();
1714 void set_allocated_session_handle(std::string* session_handle);
1715 private:
1716 const std::string& _internal_session_handle() const;
1717 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
1718 std::string* _internal_mutable_session_handle();
1719 public:
1720
1721 // @@protoc_insertion_point(class_scope:tensorflow.CloseSessionRequest)
1722 private:
1723 class _Internal;
1724
1725 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1726 typedef void InternalArenaConstructable_;
1727 typedef void DestructorSkippable_;
1728 struct Impl_ {
1729 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
1730 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1731 };
1732 union { Impl_ _impl_; };
1733 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
1734 };
1735 // -------------------------------------------------------------------
1736
1737 class CloseSessionResponse final :
1738 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.CloseSessionResponse) */ {
1739 public:
CloseSessionResponse()1740 inline CloseSessionResponse() : CloseSessionResponse(nullptr) {}
1741 ~CloseSessionResponse() override;
1742 explicit PROTOBUF_CONSTEXPR CloseSessionResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1743
1744 CloseSessionResponse(const CloseSessionResponse& from);
CloseSessionResponse(CloseSessionResponse && from)1745 CloseSessionResponse(CloseSessionResponse&& from) noexcept
1746 : CloseSessionResponse() {
1747 *this = ::std::move(from);
1748 }
1749
1750 inline CloseSessionResponse& operator=(const CloseSessionResponse& from) {
1751 if (this == &from) return *this;
1752 CopyFrom(from);
1753 return *this;
1754 }
1755 inline CloseSessionResponse& operator=(CloseSessionResponse&& from) noexcept {
1756 if (this == &from) return *this;
1757 if (GetOwningArena() == from.GetOwningArena()
1758 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1759 && GetOwningArena() != nullptr
1760 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1761 ) {
1762 InternalSwap(&from);
1763 } else {
1764 CopyFrom(from);
1765 }
1766 return *this;
1767 }
1768
default_instance()1769 static const CloseSessionResponse& default_instance() {
1770 return *internal_default_instance();
1771 }
internal_default_instance()1772 static inline const CloseSessionResponse* internal_default_instance() {
1773 return reinterpret_cast<const CloseSessionResponse*>(
1774 &_CloseSessionResponse_default_instance_);
1775 }
1776 static constexpr int kIndexInFileMessages =
1777 9;
1778
swap(CloseSessionResponse & a,CloseSessionResponse & b)1779 friend void swap(CloseSessionResponse& a, CloseSessionResponse& b) {
1780 a.Swap(&b);
1781 }
Swap(CloseSessionResponse * other)1782 inline void Swap(CloseSessionResponse* other) {
1783 if (other == this) return;
1784 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1785 if (GetOwningArena() != nullptr &&
1786 GetOwningArena() == other->GetOwningArena()) {
1787 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1788 if (GetOwningArena() == other->GetOwningArena()) {
1789 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1790 InternalSwap(other);
1791 } else {
1792 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1793 }
1794 }
1795 void UnsafeArenaSwap(CloseSessionResponse* other) {
1796 if (other == this) return;
1797 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1798 InternalSwap(other);
1799 }
1800
1801 // implements Message ----------------------------------------------
1802
1803 CloseSessionResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1804 return CreateMaybeMessage<CloseSessionResponse>(arena);
1805 }
1806 CloseSessionResponse* New() const {
1807 return New(nullptr);
1808 }
1809 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1810 void CopyFrom(const CloseSessionResponse& from);
1811 void MergeFrom(const CloseSessionResponse& from);
1812 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1813 bool IsInitialized() const final;
1814
1815 size_t ByteSizeLong() const final;
1816 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1817 ::uint8_t* _InternalSerialize(
1818 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1819 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1820
1821 private:
1822 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1823 void SharedDtor();
1824 void SetCachedSize(int size) const;
1825 void InternalSwap(CloseSessionResponse* other);
1826
1827 private:
1828 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1829 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1830 return "tensorflow.CloseSessionResponse";
1831 }
1832 protected:
1833 explicit CloseSessionResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1834 bool is_message_owned = false);
1835 public:
1836
1837 std::string GetTypeName() const final;
1838
1839 // nested types ----------------------------------------------------
1840
1841 // accessors -------------------------------------------------------
1842
1843 // @@protoc_insertion_point(class_scope:tensorflow.CloseSessionResponse)
1844 private:
1845 class _Internal;
1846
1847 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1848 typedef void InternalArenaConstructable_;
1849 typedef void DestructorSkippable_;
1850 struct Impl_ {
1851 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1852 };
1853 union { Impl_ _impl_; };
1854 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
1855 };
1856 // -------------------------------------------------------------------
1857
1858 class ResetRequest final :
1859 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ResetRequest) */ {
1860 public:
ResetRequest()1861 inline ResetRequest() : ResetRequest(nullptr) {}
1862 ~ResetRequest() override;
1863 explicit PROTOBUF_CONSTEXPR ResetRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1864
1865 ResetRequest(const ResetRequest& from);
ResetRequest(ResetRequest && from)1866 ResetRequest(ResetRequest&& from) noexcept
1867 : ResetRequest() {
1868 *this = ::std::move(from);
1869 }
1870
1871 inline ResetRequest& operator=(const ResetRequest& from) {
1872 if (this == &from) return *this;
1873 CopyFrom(from);
1874 return *this;
1875 }
1876 inline ResetRequest& operator=(ResetRequest&& from) noexcept {
1877 if (this == &from) return *this;
1878 if (GetOwningArena() == from.GetOwningArena()
1879 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1880 && GetOwningArena() != nullptr
1881 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1882 ) {
1883 InternalSwap(&from);
1884 } else {
1885 CopyFrom(from);
1886 }
1887 return *this;
1888 }
1889
default_instance()1890 static const ResetRequest& default_instance() {
1891 return *internal_default_instance();
1892 }
internal_default_instance()1893 static inline const ResetRequest* internal_default_instance() {
1894 return reinterpret_cast<const ResetRequest*>(
1895 &_ResetRequest_default_instance_);
1896 }
1897 static constexpr int kIndexInFileMessages =
1898 10;
1899
swap(ResetRequest & a,ResetRequest & b)1900 friend void swap(ResetRequest& a, ResetRequest& b) {
1901 a.Swap(&b);
1902 }
Swap(ResetRequest * other)1903 inline void Swap(ResetRequest* other) {
1904 if (other == this) return;
1905 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1906 if (GetOwningArena() != nullptr &&
1907 GetOwningArena() == other->GetOwningArena()) {
1908 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1909 if (GetOwningArena() == other->GetOwningArena()) {
1910 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1911 InternalSwap(other);
1912 } else {
1913 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1914 }
1915 }
1916 void UnsafeArenaSwap(ResetRequest* other) {
1917 if (other == this) return;
1918 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1919 InternalSwap(other);
1920 }
1921
1922 // implements Message ----------------------------------------------
1923
1924 ResetRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1925 return CreateMaybeMessage<ResetRequest>(arena);
1926 }
1927 ResetRequest* New() const {
1928 return New(nullptr);
1929 }
1930 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1931 void CopyFrom(const ResetRequest& from);
1932 void MergeFrom(const ResetRequest& from);
1933 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1934 bool IsInitialized() const final;
1935
1936 size_t ByteSizeLong() const final;
1937 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1938 ::uint8_t* _InternalSerialize(
1939 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1940 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1941
1942 private:
1943 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1944 void SharedDtor();
1945 void SetCachedSize(int size) const;
1946 void InternalSwap(ResetRequest* other);
1947
1948 private:
1949 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1950 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1951 return "tensorflow.ResetRequest";
1952 }
1953 protected:
1954 explicit ResetRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1955 bool is_message_owned = false);
1956 public:
1957
1958 std::string GetTypeName() const final;
1959
1960 // nested types ----------------------------------------------------
1961
1962 // accessors -------------------------------------------------------
1963
1964 enum : int {
1965 kContainerFieldNumber = 1,
1966 kDeviceFiltersFieldNumber = 2,
1967 };
1968 // repeated string container = 1;
1969 int container_size() const;
1970 private:
1971 int _internal_container_size() const;
1972 public:
1973 void clear_container();
1974 const std::string& container(int index) const;
1975 std::string* mutable_container(int index);
1976 void set_container(int index, const std::string& value);
1977 void set_container(int index, std::string&& value);
1978 void set_container(int index, const char* value);
1979 void set_container(int index, const char* value, size_t size);
1980 std::string* add_container();
1981 void add_container(const std::string& value);
1982 void add_container(std::string&& value);
1983 void add_container(const char* value);
1984 void add_container(const char* value, size_t size);
1985 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& container() const;
1986 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_container();
1987 private:
1988 const std::string& _internal_container(int index) const;
1989 std::string* _internal_add_container();
1990 public:
1991
1992 // repeated string device_filters = 2;
1993 int device_filters_size() const;
1994 private:
1995 int _internal_device_filters_size() const;
1996 public:
1997 void clear_device_filters();
1998 const std::string& device_filters(int index) const;
1999 std::string* mutable_device_filters(int index);
2000 void set_device_filters(int index, const std::string& value);
2001 void set_device_filters(int index, std::string&& value);
2002 void set_device_filters(int index, const char* value);
2003 void set_device_filters(int index, const char* value, size_t size);
2004 std::string* add_device_filters();
2005 void add_device_filters(const std::string& value);
2006 void add_device_filters(std::string&& value);
2007 void add_device_filters(const char* value);
2008 void add_device_filters(const char* value, size_t size);
2009 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& device_filters() const;
2010 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_device_filters();
2011 private:
2012 const std::string& _internal_device_filters(int index) const;
2013 std::string* _internal_add_device_filters();
2014 public:
2015
2016 // @@protoc_insertion_point(class_scope:tensorflow.ResetRequest)
2017 private:
2018 class _Internal;
2019
2020 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2021 typedef void InternalArenaConstructable_;
2022 typedef void DestructorSkippable_;
2023 struct Impl_ {
2024 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> container_;
2025 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> device_filters_;
2026 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2027 };
2028 union { Impl_ _impl_; };
2029 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2030 };
2031 // -------------------------------------------------------------------
2032
2033 class ResetResponse final :
2034 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ResetResponse) */ {
2035 public:
ResetResponse()2036 inline ResetResponse() : ResetResponse(nullptr) {}
2037 ~ResetResponse() override;
2038 explicit PROTOBUF_CONSTEXPR ResetResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2039
2040 ResetResponse(const ResetResponse& from);
ResetResponse(ResetResponse && from)2041 ResetResponse(ResetResponse&& from) noexcept
2042 : ResetResponse() {
2043 *this = ::std::move(from);
2044 }
2045
2046 inline ResetResponse& operator=(const ResetResponse& from) {
2047 if (this == &from) return *this;
2048 CopyFrom(from);
2049 return *this;
2050 }
2051 inline ResetResponse& operator=(ResetResponse&& from) noexcept {
2052 if (this == &from) return *this;
2053 if (GetOwningArena() == from.GetOwningArena()
2054 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2055 && GetOwningArena() != nullptr
2056 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2057 ) {
2058 InternalSwap(&from);
2059 } else {
2060 CopyFrom(from);
2061 }
2062 return *this;
2063 }
2064
default_instance()2065 static const ResetResponse& default_instance() {
2066 return *internal_default_instance();
2067 }
internal_default_instance()2068 static inline const ResetResponse* internal_default_instance() {
2069 return reinterpret_cast<const ResetResponse*>(
2070 &_ResetResponse_default_instance_);
2071 }
2072 static constexpr int kIndexInFileMessages =
2073 11;
2074
swap(ResetResponse & a,ResetResponse & b)2075 friend void swap(ResetResponse& a, ResetResponse& b) {
2076 a.Swap(&b);
2077 }
Swap(ResetResponse * other)2078 inline void Swap(ResetResponse* other) {
2079 if (other == this) return;
2080 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2081 if (GetOwningArena() != nullptr &&
2082 GetOwningArena() == other->GetOwningArena()) {
2083 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2084 if (GetOwningArena() == other->GetOwningArena()) {
2085 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2086 InternalSwap(other);
2087 } else {
2088 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2089 }
2090 }
2091 void UnsafeArenaSwap(ResetResponse* other) {
2092 if (other == this) return;
2093 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2094 InternalSwap(other);
2095 }
2096
2097 // implements Message ----------------------------------------------
2098
2099 ResetResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2100 return CreateMaybeMessage<ResetResponse>(arena);
2101 }
2102 ResetResponse* New() const {
2103 return New(nullptr);
2104 }
2105 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2106 void CopyFrom(const ResetResponse& from);
2107 void MergeFrom(const ResetResponse& from);
2108 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2109 bool IsInitialized() const final;
2110
2111 size_t ByteSizeLong() const final;
2112 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2113 ::uint8_t* _InternalSerialize(
2114 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2115 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2116
2117 private:
2118 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2119 void SharedDtor();
2120 void SetCachedSize(int size) const;
2121 void InternalSwap(ResetResponse* other);
2122
2123 private:
2124 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2125 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2126 return "tensorflow.ResetResponse";
2127 }
2128 protected:
2129 explicit ResetResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2130 bool is_message_owned = false);
2131 public:
2132
2133 std::string GetTypeName() const final;
2134
2135 // nested types ----------------------------------------------------
2136
2137 // accessors -------------------------------------------------------
2138
2139 // @@protoc_insertion_point(class_scope:tensorflow.ResetResponse)
2140 private:
2141 class _Internal;
2142
2143 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2144 typedef void InternalArenaConstructable_;
2145 typedef void DestructorSkippable_;
2146 struct Impl_ {
2147 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2148 };
2149 union { Impl_ _impl_; };
2150 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2151 };
2152 // -------------------------------------------------------------------
2153
2154 class ListDevicesRequest final :
2155 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ListDevicesRequest) */ {
2156 public:
ListDevicesRequest()2157 inline ListDevicesRequest() : ListDevicesRequest(nullptr) {}
2158 ~ListDevicesRequest() override;
2159 explicit PROTOBUF_CONSTEXPR ListDevicesRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2160
2161 ListDevicesRequest(const ListDevicesRequest& from);
ListDevicesRequest(ListDevicesRequest && from)2162 ListDevicesRequest(ListDevicesRequest&& from) noexcept
2163 : ListDevicesRequest() {
2164 *this = ::std::move(from);
2165 }
2166
2167 inline ListDevicesRequest& operator=(const ListDevicesRequest& from) {
2168 if (this == &from) return *this;
2169 CopyFrom(from);
2170 return *this;
2171 }
2172 inline ListDevicesRequest& operator=(ListDevicesRequest&& from) noexcept {
2173 if (this == &from) return *this;
2174 if (GetOwningArena() == from.GetOwningArena()
2175 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2176 && GetOwningArena() != nullptr
2177 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2178 ) {
2179 InternalSwap(&from);
2180 } else {
2181 CopyFrom(from);
2182 }
2183 return *this;
2184 }
2185
default_instance()2186 static const ListDevicesRequest& default_instance() {
2187 return *internal_default_instance();
2188 }
internal_default_instance()2189 static inline const ListDevicesRequest* internal_default_instance() {
2190 return reinterpret_cast<const ListDevicesRequest*>(
2191 &_ListDevicesRequest_default_instance_);
2192 }
2193 static constexpr int kIndexInFileMessages =
2194 12;
2195
swap(ListDevicesRequest & a,ListDevicesRequest & b)2196 friend void swap(ListDevicesRequest& a, ListDevicesRequest& b) {
2197 a.Swap(&b);
2198 }
Swap(ListDevicesRequest * other)2199 inline void Swap(ListDevicesRequest* other) {
2200 if (other == this) return;
2201 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2202 if (GetOwningArena() != nullptr &&
2203 GetOwningArena() == other->GetOwningArena()) {
2204 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2205 if (GetOwningArena() == other->GetOwningArena()) {
2206 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2207 InternalSwap(other);
2208 } else {
2209 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2210 }
2211 }
2212 void UnsafeArenaSwap(ListDevicesRequest* other) {
2213 if (other == this) return;
2214 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2215 InternalSwap(other);
2216 }
2217
2218 // implements Message ----------------------------------------------
2219
2220 ListDevicesRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2221 return CreateMaybeMessage<ListDevicesRequest>(arena);
2222 }
2223 ListDevicesRequest* New() const {
2224 return New(nullptr);
2225 }
2226 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2227 void CopyFrom(const ListDevicesRequest& from);
2228 void MergeFrom(const ListDevicesRequest& from);
2229 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2230 bool IsInitialized() const final;
2231
2232 size_t ByteSizeLong() const final;
2233 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2234 ::uint8_t* _InternalSerialize(
2235 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2236 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2237
2238 private:
2239 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2240 void SharedDtor();
2241 void SetCachedSize(int size) const;
2242 void InternalSwap(ListDevicesRequest* other);
2243
2244 private:
2245 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2246 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2247 return "tensorflow.ListDevicesRequest";
2248 }
2249 protected:
2250 explicit ListDevicesRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2251 bool is_message_owned = false);
2252 public:
2253
2254 std::string GetTypeName() const final;
2255
2256 // nested types ----------------------------------------------------
2257
2258 // accessors -------------------------------------------------------
2259
2260 enum : int {
2261 kSessionHandleFieldNumber = 1,
2262 };
2263 // string session_handle = 1;
2264 void clear_session_handle();
2265 const std::string& session_handle() const;
2266 template <typename ArgT0 = const std::string&, typename... ArgT>
2267 void set_session_handle(ArgT0&& arg0, ArgT... args);
2268 std::string* mutable_session_handle();
2269 PROTOBUF_NODISCARD std::string* release_session_handle();
2270 void set_allocated_session_handle(std::string* session_handle);
2271 private:
2272 const std::string& _internal_session_handle() const;
2273 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
2274 std::string* _internal_mutable_session_handle();
2275 public:
2276
2277 // @@protoc_insertion_point(class_scope:tensorflow.ListDevicesRequest)
2278 private:
2279 class _Internal;
2280
2281 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2282 typedef void InternalArenaConstructable_;
2283 typedef void DestructorSkippable_;
2284 struct Impl_ {
2285 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
2286 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2287 };
2288 union { Impl_ _impl_; };
2289 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2290 };
2291 // -------------------------------------------------------------------
2292
2293 class ListDevicesResponse final :
2294 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ListDevicesResponse) */ {
2295 public:
ListDevicesResponse()2296 inline ListDevicesResponse() : ListDevicesResponse(nullptr) {}
2297 ~ListDevicesResponse() override;
2298 explicit PROTOBUF_CONSTEXPR ListDevicesResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2299
2300 ListDevicesResponse(const ListDevicesResponse& from);
ListDevicesResponse(ListDevicesResponse && from)2301 ListDevicesResponse(ListDevicesResponse&& from) noexcept
2302 : ListDevicesResponse() {
2303 *this = ::std::move(from);
2304 }
2305
2306 inline ListDevicesResponse& operator=(const ListDevicesResponse& from) {
2307 if (this == &from) return *this;
2308 CopyFrom(from);
2309 return *this;
2310 }
2311 inline ListDevicesResponse& operator=(ListDevicesResponse&& from) noexcept {
2312 if (this == &from) return *this;
2313 if (GetOwningArena() == from.GetOwningArena()
2314 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2315 && GetOwningArena() != nullptr
2316 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2317 ) {
2318 InternalSwap(&from);
2319 } else {
2320 CopyFrom(from);
2321 }
2322 return *this;
2323 }
2324
default_instance()2325 static const ListDevicesResponse& default_instance() {
2326 return *internal_default_instance();
2327 }
internal_default_instance()2328 static inline const ListDevicesResponse* internal_default_instance() {
2329 return reinterpret_cast<const ListDevicesResponse*>(
2330 &_ListDevicesResponse_default_instance_);
2331 }
2332 static constexpr int kIndexInFileMessages =
2333 13;
2334
swap(ListDevicesResponse & a,ListDevicesResponse & b)2335 friend void swap(ListDevicesResponse& a, ListDevicesResponse& b) {
2336 a.Swap(&b);
2337 }
Swap(ListDevicesResponse * other)2338 inline void Swap(ListDevicesResponse* other) {
2339 if (other == this) return;
2340 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2341 if (GetOwningArena() != nullptr &&
2342 GetOwningArena() == other->GetOwningArena()) {
2343 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2344 if (GetOwningArena() == other->GetOwningArena()) {
2345 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2346 InternalSwap(other);
2347 } else {
2348 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2349 }
2350 }
2351 void UnsafeArenaSwap(ListDevicesResponse* other) {
2352 if (other == this) return;
2353 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2354 InternalSwap(other);
2355 }
2356
2357 // implements Message ----------------------------------------------
2358
2359 ListDevicesResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2360 return CreateMaybeMessage<ListDevicesResponse>(arena);
2361 }
2362 ListDevicesResponse* New() const {
2363 return New(nullptr);
2364 }
2365 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2366 void CopyFrom(const ListDevicesResponse& from);
2367 void MergeFrom(const ListDevicesResponse& from);
2368 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2369 bool IsInitialized() const final;
2370
2371 size_t ByteSizeLong() const final;
2372 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2373 ::uint8_t* _InternalSerialize(
2374 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2375 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2376
2377 private:
2378 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2379 void SharedDtor();
2380 void SetCachedSize(int size) const;
2381 void InternalSwap(ListDevicesResponse* other);
2382
2383 private:
2384 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2385 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2386 return "tensorflow.ListDevicesResponse";
2387 }
2388 protected:
2389 explicit ListDevicesResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2390 bool is_message_owned = false);
2391 public:
2392
2393 std::string GetTypeName() const final;
2394
2395 // nested types ----------------------------------------------------
2396
2397 // accessors -------------------------------------------------------
2398
2399 enum : int {
2400 kLocalDeviceFieldNumber = 1,
2401 kRemoteDeviceFieldNumber = 2,
2402 };
2403 // repeated .tensorflow.DeviceAttributes local_device = 1;
2404 int local_device_size() const;
2405 private:
2406 int _internal_local_device_size() const;
2407 public:
2408 void clear_local_device();
2409 ::tensorflow::DeviceAttributes* mutable_local_device(int index);
2410 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
2411 mutable_local_device();
2412 private:
2413 const ::tensorflow::DeviceAttributes& _internal_local_device(int index) const;
2414 ::tensorflow::DeviceAttributes* _internal_add_local_device();
2415 public:
2416 const ::tensorflow::DeviceAttributes& local_device(int index) const;
2417 ::tensorflow::DeviceAttributes* add_local_device();
2418 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
2419 local_device() const;
2420
2421 // repeated .tensorflow.DeviceAttributes remote_device = 2;
2422 int remote_device_size() const;
2423 private:
2424 int _internal_remote_device_size() const;
2425 public:
2426 void clear_remote_device();
2427 ::tensorflow::DeviceAttributes* mutable_remote_device(int index);
2428 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >*
2429 mutable_remote_device();
2430 private:
2431 const ::tensorflow::DeviceAttributes& _internal_remote_device(int index) const;
2432 ::tensorflow::DeviceAttributes* _internal_add_remote_device();
2433 public:
2434 const ::tensorflow::DeviceAttributes& remote_device(int index) const;
2435 ::tensorflow::DeviceAttributes* add_remote_device();
2436 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes >&
2437 remote_device() const;
2438
2439 // @@protoc_insertion_point(class_scope:tensorflow.ListDevicesResponse)
2440 private:
2441 class _Internal;
2442
2443 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2444 typedef void InternalArenaConstructable_;
2445 typedef void DestructorSkippable_;
2446 struct Impl_ {
2447 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes > local_device_;
2448 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DeviceAttributes > remote_device_;
2449 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2450 };
2451 union { Impl_ _impl_; };
2452 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2453 };
2454 // -------------------------------------------------------------------
2455
2456 class MakeCallableRequest final :
2457 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MakeCallableRequest) */ {
2458 public:
MakeCallableRequest()2459 inline MakeCallableRequest() : MakeCallableRequest(nullptr) {}
2460 ~MakeCallableRequest() override;
2461 explicit PROTOBUF_CONSTEXPR MakeCallableRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2462
2463 MakeCallableRequest(const MakeCallableRequest& from);
MakeCallableRequest(MakeCallableRequest && from)2464 MakeCallableRequest(MakeCallableRequest&& from) noexcept
2465 : MakeCallableRequest() {
2466 *this = ::std::move(from);
2467 }
2468
2469 inline MakeCallableRequest& operator=(const MakeCallableRequest& from) {
2470 if (this == &from) return *this;
2471 CopyFrom(from);
2472 return *this;
2473 }
2474 inline MakeCallableRequest& operator=(MakeCallableRequest&& from) noexcept {
2475 if (this == &from) return *this;
2476 if (GetOwningArena() == from.GetOwningArena()
2477 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2478 && GetOwningArena() != nullptr
2479 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2480 ) {
2481 InternalSwap(&from);
2482 } else {
2483 CopyFrom(from);
2484 }
2485 return *this;
2486 }
2487
default_instance()2488 static const MakeCallableRequest& default_instance() {
2489 return *internal_default_instance();
2490 }
internal_default_instance()2491 static inline const MakeCallableRequest* internal_default_instance() {
2492 return reinterpret_cast<const MakeCallableRequest*>(
2493 &_MakeCallableRequest_default_instance_);
2494 }
2495 static constexpr int kIndexInFileMessages =
2496 14;
2497
swap(MakeCallableRequest & a,MakeCallableRequest & b)2498 friend void swap(MakeCallableRequest& a, MakeCallableRequest& b) {
2499 a.Swap(&b);
2500 }
Swap(MakeCallableRequest * other)2501 inline void Swap(MakeCallableRequest* other) {
2502 if (other == this) return;
2503 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2504 if (GetOwningArena() != nullptr &&
2505 GetOwningArena() == other->GetOwningArena()) {
2506 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2507 if (GetOwningArena() == other->GetOwningArena()) {
2508 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2509 InternalSwap(other);
2510 } else {
2511 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2512 }
2513 }
2514 void UnsafeArenaSwap(MakeCallableRequest* other) {
2515 if (other == this) return;
2516 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2517 InternalSwap(other);
2518 }
2519
2520 // implements Message ----------------------------------------------
2521
2522 MakeCallableRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2523 return CreateMaybeMessage<MakeCallableRequest>(arena);
2524 }
2525 MakeCallableRequest* New() const {
2526 return New(nullptr);
2527 }
2528 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2529 void CopyFrom(const MakeCallableRequest& from);
2530 void MergeFrom(const MakeCallableRequest& from);
2531 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2532 bool IsInitialized() const final;
2533
2534 size_t ByteSizeLong() const final;
2535 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2536 ::uint8_t* _InternalSerialize(
2537 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2538 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2539
2540 private:
2541 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2542 void SharedDtor();
2543 void SetCachedSize(int size) const;
2544 void InternalSwap(MakeCallableRequest* other);
2545
2546 private:
2547 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2548 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2549 return "tensorflow.MakeCallableRequest";
2550 }
2551 protected:
2552 explicit MakeCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2553 bool is_message_owned = false);
2554 public:
2555
2556 std::string GetTypeName() const final;
2557
2558 // nested types ----------------------------------------------------
2559
2560 // accessors -------------------------------------------------------
2561
2562 enum : int {
2563 kSessionHandleFieldNumber = 1,
2564 kOptionsFieldNumber = 2,
2565 kRequestIdFieldNumber = 3,
2566 };
2567 // string session_handle = 1;
2568 void clear_session_handle();
2569 const std::string& session_handle() const;
2570 template <typename ArgT0 = const std::string&, typename... ArgT>
2571 void set_session_handle(ArgT0&& arg0, ArgT... args);
2572 std::string* mutable_session_handle();
2573 PROTOBUF_NODISCARD std::string* release_session_handle();
2574 void set_allocated_session_handle(std::string* session_handle);
2575 private:
2576 const std::string& _internal_session_handle() const;
2577 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
2578 std::string* _internal_mutable_session_handle();
2579 public:
2580
2581 // .tensorflow.CallableOptions options = 2;
2582 bool has_options() const;
2583 private:
2584 bool _internal_has_options() const;
2585 public:
2586 void clear_options();
2587 const ::tensorflow::CallableOptions& options() const;
2588 PROTOBUF_NODISCARD ::tensorflow::CallableOptions* release_options();
2589 ::tensorflow::CallableOptions* mutable_options();
2590 void set_allocated_options(::tensorflow::CallableOptions* options);
2591 private:
2592 const ::tensorflow::CallableOptions& _internal_options() const;
2593 ::tensorflow::CallableOptions* _internal_mutable_options();
2594 public:
2595 void unsafe_arena_set_allocated_options(
2596 ::tensorflow::CallableOptions* options);
2597 ::tensorflow::CallableOptions* unsafe_arena_release_options();
2598
2599 // int64 request_id = 3;
2600 void clear_request_id();
2601 ::int64_t request_id() const;
2602 void set_request_id(::int64_t value);
2603 private:
2604 ::int64_t _internal_request_id() const;
2605 void _internal_set_request_id(::int64_t value);
2606 public:
2607
2608 // @@protoc_insertion_point(class_scope:tensorflow.MakeCallableRequest)
2609 private:
2610 class _Internal;
2611
2612 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2613 typedef void InternalArenaConstructable_;
2614 typedef void DestructorSkippable_;
2615 struct Impl_ {
2616 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
2617 ::tensorflow::CallableOptions* options_;
2618 ::int64_t request_id_;
2619 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2620 };
2621 union { Impl_ _impl_; };
2622 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2623 };
2624 // -------------------------------------------------------------------
2625
2626 class MakeCallableResponse final :
2627 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.MakeCallableResponse) */ {
2628 public:
MakeCallableResponse()2629 inline MakeCallableResponse() : MakeCallableResponse(nullptr) {}
2630 ~MakeCallableResponse() override;
2631 explicit PROTOBUF_CONSTEXPR MakeCallableResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2632
2633 MakeCallableResponse(const MakeCallableResponse& from);
MakeCallableResponse(MakeCallableResponse && from)2634 MakeCallableResponse(MakeCallableResponse&& from) noexcept
2635 : MakeCallableResponse() {
2636 *this = ::std::move(from);
2637 }
2638
2639 inline MakeCallableResponse& operator=(const MakeCallableResponse& from) {
2640 if (this == &from) return *this;
2641 CopyFrom(from);
2642 return *this;
2643 }
2644 inline MakeCallableResponse& operator=(MakeCallableResponse&& from) noexcept {
2645 if (this == &from) return *this;
2646 if (GetOwningArena() == from.GetOwningArena()
2647 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2648 && GetOwningArena() != nullptr
2649 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2650 ) {
2651 InternalSwap(&from);
2652 } else {
2653 CopyFrom(from);
2654 }
2655 return *this;
2656 }
2657
default_instance()2658 static const MakeCallableResponse& default_instance() {
2659 return *internal_default_instance();
2660 }
internal_default_instance()2661 static inline const MakeCallableResponse* internal_default_instance() {
2662 return reinterpret_cast<const MakeCallableResponse*>(
2663 &_MakeCallableResponse_default_instance_);
2664 }
2665 static constexpr int kIndexInFileMessages =
2666 15;
2667
swap(MakeCallableResponse & a,MakeCallableResponse & b)2668 friend void swap(MakeCallableResponse& a, MakeCallableResponse& b) {
2669 a.Swap(&b);
2670 }
Swap(MakeCallableResponse * other)2671 inline void Swap(MakeCallableResponse* other) {
2672 if (other == this) return;
2673 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2674 if (GetOwningArena() != nullptr &&
2675 GetOwningArena() == other->GetOwningArena()) {
2676 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2677 if (GetOwningArena() == other->GetOwningArena()) {
2678 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2679 InternalSwap(other);
2680 } else {
2681 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2682 }
2683 }
2684 void UnsafeArenaSwap(MakeCallableResponse* other) {
2685 if (other == this) return;
2686 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2687 InternalSwap(other);
2688 }
2689
2690 // implements Message ----------------------------------------------
2691
2692 MakeCallableResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2693 return CreateMaybeMessage<MakeCallableResponse>(arena);
2694 }
2695 MakeCallableResponse* New() const {
2696 return New(nullptr);
2697 }
2698 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2699 void CopyFrom(const MakeCallableResponse& from);
2700 void MergeFrom(const MakeCallableResponse& from);
2701 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2702 bool IsInitialized() const final;
2703
2704 size_t ByteSizeLong() const final;
2705 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2706 ::uint8_t* _InternalSerialize(
2707 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2708 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2709
2710 private:
2711 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2712 void SharedDtor();
2713 void SetCachedSize(int size) const;
2714 void InternalSwap(MakeCallableResponse* other);
2715
2716 private:
2717 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2718 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2719 return "tensorflow.MakeCallableResponse";
2720 }
2721 protected:
2722 explicit MakeCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2723 bool is_message_owned = false);
2724 public:
2725
2726 std::string GetTypeName() const final;
2727
2728 // nested types ----------------------------------------------------
2729
2730 // accessors -------------------------------------------------------
2731
2732 enum : int {
2733 kHandleFieldNumber = 1,
2734 };
2735 // int64 handle = 1;
2736 void clear_handle();
2737 ::int64_t handle() const;
2738 void set_handle(::int64_t value);
2739 private:
2740 ::int64_t _internal_handle() const;
2741 void _internal_set_handle(::int64_t value);
2742 public:
2743
2744 // @@protoc_insertion_point(class_scope:tensorflow.MakeCallableResponse)
2745 private:
2746 class _Internal;
2747
2748 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2749 typedef void InternalArenaConstructable_;
2750 typedef void DestructorSkippable_;
2751 struct Impl_ {
2752 ::int64_t handle_;
2753 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2754 };
2755 union { Impl_ _impl_; };
2756 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2757 };
2758 // -------------------------------------------------------------------
2759
2760 class RunCallableRequest final :
2761 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RunCallableRequest) */ {
2762 public:
RunCallableRequest()2763 inline RunCallableRequest() : RunCallableRequest(nullptr) {}
2764 ~RunCallableRequest() override;
2765 explicit PROTOBUF_CONSTEXPR RunCallableRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2766
2767 RunCallableRequest(const RunCallableRequest& from);
RunCallableRequest(RunCallableRequest && from)2768 RunCallableRequest(RunCallableRequest&& from) noexcept
2769 : RunCallableRequest() {
2770 *this = ::std::move(from);
2771 }
2772
2773 inline RunCallableRequest& operator=(const RunCallableRequest& from) {
2774 if (this == &from) return *this;
2775 CopyFrom(from);
2776 return *this;
2777 }
2778 inline RunCallableRequest& operator=(RunCallableRequest&& from) noexcept {
2779 if (this == &from) return *this;
2780 if (GetOwningArena() == from.GetOwningArena()
2781 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2782 && GetOwningArena() != nullptr
2783 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2784 ) {
2785 InternalSwap(&from);
2786 } else {
2787 CopyFrom(from);
2788 }
2789 return *this;
2790 }
2791
default_instance()2792 static const RunCallableRequest& default_instance() {
2793 return *internal_default_instance();
2794 }
internal_default_instance()2795 static inline const RunCallableRequest* internal_default_instance() {
2796 return reinterpret_cast<const RunCallableRequest*>(
2797 &_RunCallableRequest_default_instance_);
2798 }
2799 static constexpr int kIndexInFileMessages =
2800 16;
2801
swap(RunCallableRequest & a,RunCallableRequest & b)2802 friend void swap(RunCallableRequest& a, RunCallableRequest& b) {
2803 a.Swap(&b);
2804 }
Swap(RunCallableRequest * other)2805 inline void Swap(RunCallableRequest* other) {
2806 if (other == this) return;
2807 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2808 if (GetOwningArena() != nullptr &&
2809 GetOwningArena() == other->GetOwningArena()) {
2810 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2811 if (GetOwningArena() == other->GetOwningArena()) {
2812 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2813 InternalSwap(other);
2814 } else {
2815 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2816 }
2817 }
2818 void UnsafeArenaSwap(RunCallableRequest* other) {
2819 if (other == this) return;
2820 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
2821 InternalSwap(other);
2822 }
2823
2824 // implements Message ----------------------------------------------
2825
2826 RunCallableRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2827 return CreateMaybeMessage<RunCallableRequest>(arena);
2828 }
2829 RunCallableRequest* New() const {
2830 return New(nullptr);
2831 }
2832 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
2833 void CopyFrom(const RunCallableRequest& from);
2834 void MergeFrom(const RunCallableRequest& from);
2835 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2836 bool IsInitialized() const final;
2837
2838 size_t ByteSizeLong() const final;
2839 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2840 ::uint8_t* _InternalSerialize(
2841 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
2842 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
2843
2844 private:
2845 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
2846 void SharedDtor();
2847 void SetCachedSize(int size) const;
2848 void InternalSwap(RunCallableRequest* other);
2849
2850 private:
2851 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2852 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2853 return "tensorflow.RunCallableRequest";
2854 }
2855 protected:
2856 explicit RunCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2857 bool is_message_owned = false);
2858 public:
2859
2860 std::string GetTypeName() const final;
2861
2862 // nested types ----------------------------------------------------
2863
2864 // accessors -------------------------------------------------------
2865
2866 enum : int {
2867 kFeedFieldNumber = 3,
2868 kSessionHandleFieldNumber = 1,
2869 kHandleFieldNumber = 2,
2870 kRequestIdFieldNumber = 4,
2871 };
2872 // repeated .tensorflow.TensorProto feed = 3;
2873 int feed_size() const;
2874 private:
2875 int _internal_feed_size() const;
2876 public:
2877 void clear_feed();
2878 ::tensorflow::TensorProto* mutable_feed(int index);
2879 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
2880 mutable_feed();
2881 private:
2882 const ::tensorflow::TensorProto& _internal_feed(int index) const;
2883 ::tensorflow::TensorProto* _internal_add_feed();
2884 public:
2885 const ::tensorflow::TensorProto& feed(int index) const;
2886 ::tensorflow::TensorProto* add_feed();
2887 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
2888 feed() const;
2889
2890 // string session_handle = 1;
2891 void clear_session_handle();
2892 const std::string& session_handle() const;
2893 template <typename ArgT0 = const std::string&, typename... ArgT>
2894 void set_session_handle(ArgT0&& arg0, ArgT... args);
2895 std::string* mutable_session_handle();
2896 PROTOBUF_NODISCARD std::string* release_session_handle();
2897 void set_allocated_session_handle(std::string* session_handle);
2898 private:
2899 const std::string& _internal_session_handle() const;
2900 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
2901 std::string* _internal_mutable_session_handle();
2902 public:
2903
2904 // int64 handle = 2;
2905 void clear_handle();
2906 ::int64_t handle() const;
2907 void set_handle(::int64_t value);
2908 private:
2909 ::int64_t _internal_handle() const;
2910 void _internal_set_handle(::int64_t value);
2911 public:
2912
2913 // int64 request_id = 4;
2914 void clear_request_id();
2915 ::int64_t request_id() const;
2916 void set_request_id(::int64_t value);
2917 private:
2918 ::int64_t _internal_request_id() const;
2919 void _internal_set_request_id(::int64_t value);
2920 public:
2921
2922 // @@protoc_insertion_point(class_scope:tensorflow.RunCallableRequest)
2923 private:
2924 class _Internal;
2925
2926 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2927 typedef void InternalArenaConstructable_;
2928 typedef void DestructorSkippable_;
2929 struct Impl_ {
2930 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto > feed_;
2931 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
2932 ::int64_t handle_;
2933 ::int64_t request_id_;
2934 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2935 };
2936 union { Impl_ _impl_; };
2937 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
2938 };
2939 // -------------------------------------------------------------------
2940
2941 class RunCallableResponse final :
2942 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.RunCallableResponse) */ {
2943 public:
RunCallableResponse()2944 inline RunCallableResponse() : RunCallableResponse(nullptr) {}
2945 ~RunCallableResponse() override;
2946 explicit PROTOBUF_CONSTEXPR RunCallableResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
2947
2948 RunCallableResponse(const RunCallableResponse& from);
RunCallableResponse(RunCallableResponse && from)2949 RunCallableResponse(RunCallableResponse&& from) noexcept
2950 : RunCallableResponse() {
2951 *this = ::std::move(from);
2952 }
2953
2954 inline RunCallableResponse& operator=(const RunCallableResponse& from) {
2955 if (this == &from) return *this;
2956 CopyFrom(from);
2957 return *this;
2958 }
2959 inline RunCallableResponse& operator=(RunCallableResponse&& from) noexcept {
2960 if (this == &from) return *this;
2961 if (GetOwningArena() == from.GetOwningArena()
2962 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
2963 && GetOwningArena() != nullptr
2964 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
2965 ) {
2966 InternalSwap(&from);
2967 } else {
2968 CopyFrom(from);
2969 }
2970 return *this;
2971 }
2972
default_instance()2973 static const RunCallableResponse& default_instance() {
2974 return *internal_default_instance();
2975 }
internal_default_instance()2976 static inline const RunCallableResponse* internal_default_instance() {
2977 return reinterpret_cast<const RunCallableResponse*>(
2978 &_RunCallableResponse_default_instance_);
2979 }
2980 static constexpr int kIndexInFileMessages =
2981 17;
2982
swap(RunCallableResponse & a,RunCallableResponse & b)2983 friend void swap(RunCallableResponse& a, RunCallableResponse& b) {
2984 a.Swap(&b);
2985 }
Swap(RunCallableResponse * other)2986 inline void Swap(RunCallableResponse* other) {
2987 if (other == this) return;
2988 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
2989 if (GetOwningArena() != nullptr &&
2990 GetOwningArena() == other->GetOwningArena()) {
2991 #else // PROTOBUF_FORCE_COPY_IN_SWAP
2992 if (GetOwningArena() == other->GetOwningArena()) {
2993 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
2994 InternalSwap(other);
2995 } else {
2996 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2997 }
2998 }
2999 void UnsafeArenaSwap(RunCallableResponse* other) {
3000 if (other == this) return;
3001 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3002 InternalSwap(other);
3003 }
3004
3005 // implements Message ----------------------------------------------
3006
3007 RunCallableResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3008 return CreateMaybeMessage<RunCallableResponse>(arena);
3009 }
3010 RunCallableResponse* New() const {
3011 return New(nullptr);
3012 }
3013 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3014 void CopyFrom(const RunCallableResponse& from);
3015 void MergeFrom(const RunCallableResponse& from);
3016 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3017 bool IsInitialized() const final;
3018
3019 size_t ByteSizeLong() const final;
3020 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3021 ::uint8_t* _InternalSerialize(
3022 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3023 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3024
3025 private:
3026 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3027 void SharedDtor();
3028 void SetCachedSize(int size) const;
3029 void InternalSwap(RunCallableResponse* other);
3030
3031 private:
3032 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3033 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3034 return "tensorflow.RunCallableResponse";
3035 }
3036 protected:
3037 explicit RunCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3038 bool is_message_owned = false);
3039 public:
3040
3041 std::string GetTypeName() const final;
3042
3043 // nested types ----------------------------------------------------
3044
3045 // accessors -------------------------------------------------------
3046
3047 enum : int {
3048 kFetchFieldNumber = 1,
3049 kMetadataFieldNumber = 2,
3050 };
3051 // repeated .tensorflow.TensorProto fetch = 1;
3052 int fetch_size() const;
3053 private:
3054 int _internal_fetch_size() const;
3055 public:
3056 void clear_fetch();
3057 ::tensorflow::TensorProto* mutable_fetch(int index);
3058 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
3059 mutable_fetch();
3060 private:
3061 const ::tensorflow::TensorProto& _internal_fetch(int index) const;
3062 ::tensorflow::TensorProto* _internal_add_fetch();
3063 public:
3064 const ::tensorflow::TensorProto& fetch(int index) const;
3065 ::tensorflow::TensorProto* add_fetch();
3066 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
3067 fetch() const;
3068
3069 // .tensorflow.RunMetadata metadata = 2;
3070 bool has_metadata() const;
3071 private:
3072 bool _internal_has_metadata() const;
3073 public:
3074 void clear_metadata();
3075 const ::tensorflow::RunMetadata& metadata() const;
3076 PROTOBUF_NODISCARD ::tensorflow::RunMetadata* release_metadata();
3077 ::tensorflow::RunMetadata* mutable_metadata();
3078 void set_allocated_metadata(::tensorflow::RunMetadata* metadata);
3079 private:
3080 const ::tensorflow::RunMetadata& _internal_metadata() const;
3081 ::tensorflow::RunMetadata* _internal_mutable_metadata();
3082 public:
3083 void unsafe_arena_set_allocated_metadata(
3084 ::tensorflow::RunMetadata* metadata);
3085 ::tensorflow::RunMetadata* unsafe_arena_release_metadata();
3086
3087 // @@protoc_insertion_point(class_scope:tensorflow.RunCallableResponse)
3088 private:
3089 class _Internal;
3090
3091 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3092 typedef void InternalArenaConstructable_;
3093 typedef void DestructorSkippable_;
3094 struct Impl_ {
3095 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto > fetch_;
3096 ::tensorflow::RunMetadata* metadata_;
3097 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3098 };
3099 union { Impl_ _impl_; };
3100 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
3101 };
3102 // -------------------------------------------------------------------
3103
3104 class ReleaseCallableRequest final :
3105 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ReleaseCallableRequest) */ {
3106 public:
ReleaseCallableRequest()3107 inline ReleaseCallableRequest() : ReleaseCallableRequest(nullptr) {}
3108 ~ReleaseCallableRequest() override;
3109 explicit PROTOBUF_CONSTEXPR ReleaseCallableRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3110
3111 ReleaseCallableRequest(const ReleaseCallableRequest& from);
ReleaseCallableRequest(ReleaseCallableRequest && from)3112 ReleaseCallableRequest(ReleaseCallableRequest&& from) noexcept
3113 : ReleaseCallableRequest() {
3114 *this = ::std::move(from);
3115 }
3116
3117 inline ReleaseCallableRequest& operator=(const ReleaseCallableRequest& from) {
3118 if (this == &from) return *this;
3119 CopyFrom(from);
3120 return *this;
3121 }
3122 inline ReleaseCallableRequest& operator=(ReleaseCallableRequest&& from) noexcept {
3123 if (this == &from) return *this;
3124 if (GetOwningArena() == from.GetOwningArena()
3125 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3126 && GetOwningArena() != nullptr
3127 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3128 ) {
3129 InternalSwap(&from);
3130 } else {
3131 CopyFrom(from);
3132 }
3133 return *this;
3134 }
3135
default_instance()3136 static const ReleaseCallableRequest& default_instance() {
3137 return *internal_default_instance();
3138 }
internal_default_instance()3139 static inline const ReleaseCallableRequest* internal_default_instance() {
3140 return reinterpret_cast<const ReleaseCallableRequest*>(
3141 &_ReleaseCallableRequest_default_instance_);
3142 }
3143 static constexpr int kIndexInFileMessages =
3144 18;
3145
swap(ReleaseCallableRequest & a,ReleaseCallableRequest & b)3146 friend void swap(ReleaseCallableRequest& a, ReleaseCallableRequest& b) {
3147 a.Swap(&b);
3148 }
Swap(ReleaseCallableRequest * other)3149 inline void Swap(ReleaseCallableRequest* other) {
3150 if (other == this) return;
3151 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3152 if (GetOwningArena() != nullptr &&
3153 GetOwningArena() == other->GetOwningArena()) {
3154 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3155 if (GetOwningArena() == other->GetOwningArena()) {
3156 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3157 InternalSwap(other);
3158 } else {
3159 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3160 }
3161 }
3162 void UnsafeArenaSwap(ReleaseCallableRequest* other) {
3163 if (other == this) return;
3164 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3165 InternalSwap(other);
3166 }
3167
3168 // implements Message ----------------------------------------------
3169
3170 ReleaseCallableRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3171 return CreateMaybeMessage<ReleaseCallableRequest>(arena);
3172 }
3173 ReleaseCallableRequest* New() const {
3174 return New(nullptr);
3175 }
3176 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3177 void CopyFrom(const ReleaseCallableRequest& from);
3178 void MergeFrom(const ReleaseCallableRequest& from);
3179 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3180 bool IsInitialized() const final;
3181
3182 size_t ByteSizeLong() const final;
3183 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3184 ::uint8_t* _InternalSerialize(
3185 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3186 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3187
3188 private:
3189 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3190 void SharedDtor();
3191 void SetCachedSize(int size) const;
3192 void InternalSwap(ReleaseCallableRequest* other);
3193
3194 private:
3195 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3196 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3197 return "tensorflow.ReleaseCallableRequest";
3198 }
3199 protected:
3200 explicit ReleaseCallableRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3201 bool is_message_owned = false);
3202 public:
3203
3204 std::string GetTypeName() const final;
3205
3206 // nested types ----------------------------------------------------
3207
3208 // accessors -------------------------------------------------------
3209
3210 enum : int {
3211 kSessionHandleFieldNumber = 1,
3212 kHandleFieldNumber = 2,
3213 };
3214 // string session_handle = 1;
3215 void clear_session_handle();
3216 const std::string& session_handle() const;
3217 template <typename ArgT0 = const std::string&, typename... ArgT>
3218 void set_session_handle(ArgT0&& arg0, ArgT... args);
3219 std::string* mutable_session_handle();
3220 PROTOBUF_NODISCARD std::string* release_session_handle();
3221 void set_allocated_session_handle(std::string* session_handle);
3222 private:
3223 const std::string& _internal_session_handle() const;
3224 inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_handle(const std::string& value);
3225 std::string* _internal_mutable_session_handle();
3226 public:
3227
3228 // int64 handle = 2;
3229 void clear_handle();
3230 ::int64_t handle() const;
3231 void set_handle(::int64_t value);
3232 private:
3233 ::int64_t _internal_handle() const;
3234 void _internal_set_handle(::int64_t value);
3235 public:
3236
3237 // @@protoc_insertion_point(class_scope:tensorflow.ReleaseCallableRequest)
3238 private:
3239 class _Internal;
3240
3241 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3242 typedef void InternalArenaConstructable_;
3243 typedef void DestructorSkippable_;
3244 struct Impl_ {
3245 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
3246 ::int64_t handle_;
3247 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3248 };
3249 union { Impl_ _impl_; };
3250 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
3251 };
3252 // -------------------------------------------------------------------
3253
3254 class ReleaseCallableResponse final :
3255 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.ReleaseCallableResponse) */ {
3256 public:
ReleaseCallableResponse()3257 inline ReleaseCallableResponse() : ReleaseCallableResponse(nullptr) {}
3258 ~ReleaseCallableResponse() override;
3259 explicit PROTOBUF_CONSTEXPR ReleaseCallableResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
3260
3261 ReleaseCallableResponse(const ReleaseCallableResponse& from);
ReleaseCallableResponse(ReleaseCallableResponse && from)3262 ReleaseCallableResponse(ReleaseCallableResponse&& from) noexcept
3263 : ReleaseCallableResponse() {
3264 *this = ::std::move(from);
3265 }
3266
3267 inline ReleaseCallableResponse& operator=(const ReleaseCallableResponse& from) {
3268 if (this == &from) return *this;
3269 CopyFrom(from);
3270 return *this;
3271 }
3272 inline ReleaseCallableResponse& operator=(ReleaseCallableResponse&& from) noexcept {
3273 if (this == &from) return *this;
3274 if (GetOwningArena() == from.GetOwningArena()
3275 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
3276 && GetOwningArena() != nullptr
3277 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
3278 ) {
3279 InternalSwap(&from);
3280 } else {
3281 CopyFrom(from);
3282 }
3283 return *this;
3284 }
3285
default_instance()3286 static const ReleaseCallableResponse& default_instance() {
3287 return *internal_default_instance();
3288 }
internal_default_instance()3289 static inline const ReleaseCallableResponse* internal_default_instance() {
3290 return reinterpret_cast<const ReleaseCallableResponse*>(
3291 &_ReleaseCallableResponse_default_instance_);
3292 }
3293 static constexpr int kIndexInFileMessages =
3294 19;
3295
swap(ReleaseCallableResponse & a,ReleaseCallableResponse & b)3296 friend void swap(ReleaseCallableResponse& a, ReleaseCallableResponse& b) {
3297 a.Swap(&b);
3298 }
Swap(ReleaseCallableResponse * other)3299 inline void Swap(ReleaseCallableResponse* other) {
3300 if (other == this) return;
3301 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
3302 if (GetOwningArena() != nullptr &&
3303 GetOwningArena() == other->GetOwningArena()) {
3304 #else // PROTOBUF_FORCE_COPY_IN_SWAP
3305 if (GetOwningArena() == other->GetOwningArena()) {
3306 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
3307 InternalSwap(other);
3308 } else {
3309 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
3310 }
3311 }
3312 void UnsafeArenaSwap(ReleaseCallableResponse* other) {
3313 if (other == this) return;
3314 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
3315 InternalSwap(other);
3316 }
3317
3318 // implements Message ----------------------------------------------
3319
3320 ReleaseCallableResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
3321 return CreateMaybeMessage<ReleaseCallableResponse>(arena);
3322 }
3323 ReleaseCallableResponse* New() const {
3324 return New(nullptr);
3325 }
3326 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
3327 void CopyFrom(const ReleaseCallableResponse& from);
3328 void MergeFrom(const ReleaseCallableResponse& from);
3329 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
3330 bool IsInitialized() const final;
3331
3332 size_t ByteSizeLong() const final;
3333 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
3334 ::uint8_t* _InternalSerialize(
3335 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
3336 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
3337
3338 private:
3339 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
3340 void SharedDtor();
3341 void SetCachedSize(int size) const;
3342 void InternalSwap(ReleaseCallableResponse* other);
3343
3344 private:
3345 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
3346 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
3347 return "tensorflow.ReleaseCallableResponse";
3348 }
3349 protected:
3350 explicit ReleaseCallableResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3351 bool is_message_owned = false);
3352 public:
3353
3354 std::string GetTypeName() const final;
3355
3356 // nested types ----------------------------------------------------
3357
3358 // accessors -------------------------------------------------------
3359
3360 // @@protoc_insertion_point(class_scope:tensorflow.ReleaseCallableResponse)
3361 private:
3362 class _Internal;
3363
3364 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
3365 typedef void InternalArenaConstructable_;
3366 typedef void DestructorSkippable_;
3367 struct Impl_ {
3368 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
3369 };
3370 union { Impl_ _impl_; };
3371 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fmaster_2eproto;
3372 };
3373 // ===================================================================
3374
3375
3376 // ===================================================================
3377
3378 #ifdef __GNUC__
3379 #pragma GCC diagnostic push
3380 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
3381 #endif // __GNUC__
3382 // CreateSessionRequest
3383
3384 // .tensorflow.GraphDef graph_def = 1;
_internal_has_graph_def()3385 inline bool CreateSessionRequest::_internal_has_graph_def() const {
3386 return this != internal_default_instance() && _impl_.graph_def_ != nullptr;
3387 }
has_graph_def()3388 inline bool CreateSessionRequest::has_graph_def() const {
3389 return _internal_has_graph_def();
3390 }
_internal_graph_def()3391 inline const ::tensorflow::GraphDef& CreateSessionRequest::_internal_graph_def() const {
3392 const ::tensorflow::GraphDef* p = _impl_.graph_def_;
3393 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::GraphDef&>(
3394 ::tensorflow::_GraphDef_default_instance_);
3395 }
graph_def()3396 inline const ::tensorflow::GraphDef& CreateSessionRequest::graph_def() const {
3397 // @@protoc_insertion_point(field_get:tensorflow.CreateSessionRequest.graph_def)
3398 return _internal_graph_def();
3399 }
unsafe_arena_set_allocated_graph_def(::tensorflow::GraphDef * graph_def)3400 inline void CreateSessionRequest::unsafe_arena_set_allocated_graph_def(
3401 ::tensorflow::GraphDef* graph_def) {
3402 if (GetArenaForAllocation() == nullptr) {
3403 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_def_);
3404 }
3405 _impl_.graph_def_ = graph_def;
3406 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CreateSessionRequest.graph_def)
3407 }
release_graph_def()3408 inline ::tensorflow::GraphDef* CreateSessionRequest::release_graph_def() {
3409
3410 ::tensorflow::GraphDef* temp = _impl_.graph_def_;
3411 _impl_.graph_def_ = nullptr;
3412 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3413 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3414 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3415 if (GetArenaForAllocation() == nullptr) { delete old; }
3416 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3417 if (GetArenaForAllocation() != nullptr) {
3418 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3419 }
3420 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3421 return temp;
3422 }
unsafe_arena_release_graph_def()3423 inline ::tensorflow::GraphDef* CreateSessionRequest::unsafe_arena_release_graph_def() {
3424 // @@protoc_insertion_point(field_release:tensorflow.CreateSessionRequest.graph_def)
3425
3426 ::tensorflow::GraphDef* temp = _impl_.graph_def_;
3427 _impl_.graph_def_ = nullptr;
3428 return temp;
3429 }
_internal_mutable_graph_def()3430 inline ::tensorflow::GraphDef* CreateSessionRequest::_internal_mutable_graph_def() {
3431
3432 if (_impl_.graph_def_ == nullptr) {
3433 auto* p = CreateMaybeMessage<::tensorflow::GraphDef>(GetArenaForAllocation());
3434 _impl_.graph_def_ = p;
3435 }
3436 return _impl_.graph_def_;
3437 }
mutable_graph_def()3438 inline ::tensorflow::GraphDef* CreateSessionRequest::mutable_graph_def() {
3439 ::tensorflow::GraphDef* _msg = _internal_mutable_graph_def();
3440 // @@protoc_insertion_point(field_mutable:tensorflow.CreateSessionRequest.graph_def)
3441 return _msg;
3442 }
set_allocated_graph_def(::tensorflow::GraphDef * graph_def)3443 inline void CreateSessionRequest::set_allocated_graph_def(::tensorflow::GraphDef* graph_def) {
3444 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3445 if (message_arena == nullptr) {
3446 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_def_);
3447 }
3448 if (graph_def) {
3449 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3450 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3451 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_def));
3452 if (message_arena != submessage_arena) {
3453 graph_def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3454 message_arena, graph_def, submessage_arena);
3455 }
3456
3457 } else {
3458
3459 }
3460 _impl_.graph_def_ = graph_def;
3461 // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateSessionRequest.graph_def)
3462 }
3463
3464 // .tensorflow.ConfigProto config = 2;
_internal_has_config()3465 inline bool CreateSessionRequest::_internal_has_config() const {
3466 return this != internal_default_instance() && _impl_.config_ != nullptr;
3467 }
has_config()3468 inline bool CreateSessionRequest::has_config() const {
3469 return _internal_has_config();
3470 }
_internal_config()3471 inline const ::tensorflow::ConfigProto& CreateSessionRequest::_internal_config() const {
3472 const ::tensorflow::ConfigProto* p = _impl_.config_;
3473 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::ConfigProto&>(
3474 ::tensorflow::_ConfigProto_default_instance_);
3475 }
config()3476 inline const ::tensorflow::ConfigProto& CreateSessionRequest::config() const {
3477 // @@protoc_insertion_point(field_get:tensorflow.CreateSessionRequest.config)
3478 return _internal_config();
3479 }
unsafe_arena_set_allocated_config(::tensorflow::ConfigProto * config)3480 inline void CreateSessionRequest::unsafe_arena_set_allocated_config(
3481 ::tensorflow::ConfigProto* config) {
3482 if (GetArenaForAllocation() == nullptr) {
3483 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.config_);
3484 }
3485 _impl_.config_ = config;
3486 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CreateSessionRequest.config)
3487 }
release_config()3488 inline ::tensorflow::ConfigProto* CreateSessionRequest::release_config() {
3489
3490 ::tensorflow::ConfigProto* temp = _impl_.config_;
3491 _impl_.config_ = nullptr;
3492 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3493 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3494 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3495 if (GetArenaForAllocation() == nullptr) { delete old; }
3496 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3497 if (GetArenaForAllocation() != nullptr) {
3498 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3499 }
3500 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3501 return temp;
3502 }
unsafe_arena_release_config()3503 inline ::tensorflow::ConfigProto* CreateSessionRequest::unsafe_arena_release_config() {
3504 // @@protoc_insertion_point(field_release:tensorflow.CreateSessionRequest.config)
3505
3506 ::tensorflow::ConfigProto* temp = _impl_.config_;
3507 _impl_.config_ = nullptr;
3508 return temp;
3509 }
_internal_mutable_config()3510 inline ::tensorflow::ConfigProto* CreateSessionRequest::_internal_mutable_config() {
3511
3512 if (_impl_.config_ == nullptr) {
3513 auto* p = CreateMaybeMessage<::tensorflow::ConfigProto>(GetArenaForAllocation());
3514 _impl_.config_ = p;
3515 }
3516 return _impl_.config_;
3517 }
mutable_config()3518 inline ::tensorflow::ConfigProto* CreateSessionRequest::mutable_config() {
3519 ::tensorflow::ConfigProto* _msg = _internal_mutable_config();
3520 // @@protoc_insertion_point(field_mutable:tensorflow.CreateSessionRequest.config)
3521 return _msg;
3522 }
set_allocated_config(::tensorflow::ConfigProto * config)3523 inline void CreateSessionRequest::set_allocated_config(::tensorflow::ConfigProto* config) {
3524 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3525 if (message_arena == nullptr) {
3526 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.config_);
3527 }
3528 if (config) {
3529 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3530 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3531 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(config));
3532 if (message_arena != submessage_arena) {
3533 config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3534 message_arena, config, submessage_arena);
3535 }
3536
3537 } else {
3538
3539 }
3540 _impl_.config_ = config;
3541 // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateSessionRequest.config)
3542 }
3543
3544 // string target = 3;
clear_target()3545 inline void CreateSessionRequest::clear_target() {
3546 _impl_.target_.ClearToEmpty();
3547 }
target()3548 inline const std::string& CreateSessionRequest::target() const {
3549 // @@protoc_insertion_point(field_get:tensorflow.CreateSessionRequest.target)
3550 return _internal_target();
3551 }
3552 template <typename ArgT0, typename... ArgT>
3553 inline PROTOBUF_ALWAYS_INLINE
set_target(ArgT0 && arg0,ArgT...args)3554 void CreateSessionRequest::set_target(ArgT0&& arg0, ArgT... args) {
3555
3556 _impl_.target_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3557 // @@protoc_insertion_point(field_set:tensorflow.CreateSessionRequest.target)
3558 }
mutable_target()3559 inline std::string* CreateSessionRequest::mutable_target() {
3560 std::string* _s = _internal_mutable_target();
3561 // @@protoc_insertion_point(field_mutable:tensorflow.CreateSessionRequest.target)
3562 return _s;
3563 }
_internal_target()3564 inline const std::string& CreateSessionRequest::_internal_target() const {
3565 return _impl_.target_.Get();
3566 }
_internal_set_target(const std::string & value)3567 inline void CreateSessionRequest::_internal_set_target(const std::string& value) {
3568
3569 _impl_.target_.Set(value, GetArenaForAllocation());
3570 }
_internal_mutable_target()3571 inline std::string* CreateSessionRequest::_internal_mutable_target() {
3572
3573 return _impl_.target_.Mutable(GetArenaForAllocation());
3574 }
release_target()3575 inline std::string* CreateSessionRequest::release_target() {
3576 // @@protoc_insertion_point(field_release:tensorflow.CreateSessionRequest.target)
3577 return _impl_.target_.Release();
3578 }
set_allocated_target(std::string * target)3579 inline void CreateSessionRequest::set_allocated_target(std::string* target) {
3580 _impl_.target_.SetAllocated(target, GetArenaForAllocation());
3581 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3582 if (_impl_.target_.IsDefault()) {
3583 _impl_.target_.Set("", GetArenaForAllocation());
3584 }
3585 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3586 // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateSessionRequest.target)
3587 }
3588
3589 // -------------------------------------------------------------------
3590
3591 // CreateSessionResponse
3592
3593 // string session_handle = 1;
clear_session_handle()3594 inline void CreateSessionResponse::clear_session_handle() {
3595 _impl_.session_handle_.ClearToEmpty();
3596 }
session_handle()3597 inline const std::string& CreateSessionResponse::session_handle() const {
3598 // @@protoc_insertion_point(field_get:tensorflow.CreateSessionResponse.session_handle)
3599 return _internal_session_handle();
3600 }
3601 template <typename ArgT0, typename... ArgT>
3602 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)3603 void CreateSessionResponse::set_session_handle(ArgT0&& arg0, ArgT... args) {
3604
3605 _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3606 // @@protoc_insertion_point(field_set:tensorflow.CreateSessionResponse.session_handle)
3607 }
mutable_session_handle()3608 inline std::string* CreateSessionResponse::mutable_session_handle() {
3609 std::string* _s = _internal_mutable_session_handle();
3610 // @@protoc_insertion_point(field_mutable:tensorflow.CreateSessionResponse.session_handle)
3611 return _s;
3612 }
_internal_session_handle()3613 inline const std::string& CreateSessionResponse::_internal_session_handle() const {
3614 return _impl_.session_handle_.Get();
3615 }
_internal_set_session_handle(const std::string & value)3616 inline void CreateSessionResponse::_internal_set_session_handle(const std::string& value) {
3617
3618 _impl_.session_handle_.Set(value, GetArenaForAllocation());
3619 }
_internal_mutable_session_handle()3620 inline std::string* CreateSessionResponse::_internal_mutable_session_handle() {
3621
3622 return _impl_.session_handle_.Mutable(GetArenaForAllocation());
3623 }
release_session_handle()3624 inline std::string* CreateSessionResponse::release_session_handle() {
3625 // @@protoc_insertion_point(field_release:tensorflow.CreateSessionResponse.session_handle)
3626 return _impl_.session_handle_.Release();
3627 }
set_allocated_session_handle(std::string * session_handle)3628 inline void CreateSessionResponse::set_allocated_session_handle(std::string* session_handle) {
3629 _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
3630 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3631 if (_impl_.session_handle_.IsDefault()) {
3632 _impl_.session_handle_.Set("", GetArenaForAllocation());
3633 }
3634 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3635 // @@protoc_insertion_point(field_set_allocated:tensorflow.CreateSessionResponse.session_handle)
3636 }
3637
3638 // int64 graph_version = 2;
clear_graph_version()3639 inline void CreateSessionResponse::clear_graph_version() {
3640 _impl_.graph_version_ = ::int64_t{0};
3641 }
_internal_graph_version()3642 inline ::int64_t CreateSessionResponse::_internal_graph_version() const {
3643 return _impl_.graph_version_;
3644 }
graph_version()3645 inline ::int64_t CreateSessionResponse::graph_version() const {
3646 // @@protoc_insertion_point(field_get:tensorflow.CreateSessionResponse.graph_version)
3647 return _internal_graph_version();
3648 }
_internal_set_graph_version(::int64_t value)3649 inline void CreateSessionResponse::_internal_set_graph_version(::int64_t value) {
3650
3651 _impl_.graph_version_ = value;
3652 }
set_graph_version(::int64_t value)3653 inline void CreateSessionResponse::set_graph_version(::int64_t value) {
3654 _internal_set_graph_version(value);
3655 // @@protoc_insertion_point(field_set:tensorflow.CreateSessionResponse.graph_version)
3656 }
3657
3658 // -------------------------------------------------------------------
3659
3660 // ExtendSessionRequest
3661
3662 // string session_handle = 1;
clear_session_handle()3663 inline void ExtendSessionRequest::clear_session_handle() {
3664 _impl_.session_handle_.ClearToEmpty();
3665 }
session_handle()3666 inline const std::string& ExtendSessionRequest::session_handle() const {
3667 // @@protoc_insertion_point(field_get:tensorflow.ExtendSessionRequest.session_handle)
3668 return _internal_session_handle();
3669 }
3670 template <typename ArgT0, typename... ArgT>
3671 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)3672 void ExtendSessionRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
3673
3674 _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3675 // @@protoc_insertion_point(field_set:tensorflow.ExtendSessionRequest.session_handle)
3676 }
mutable_session_handle()3677 inline std::string* ExtendSessionRequest::mutable_session_handle() {
3678 std::string* _s = _internal_mutable_session_handle();
3679 // @@protoc_insertion_point(field_mutable:tensorflow.ExtendSessionRequest.session_handle)
3680 return _s;
3681 }
_internal_session_handle()3682 inline const std::string& ExtendSessionRequest::_internal_session_handle() const {
3683 return _impl_.session_handle_.Get();
3684 }
_internal_set_session_handle(const std::string & value)3685 inline void ExtendSessionRequest::_internal_set_session_handle(const std::string& value) {
3686
3687 _impl_.session_handle_.Set(value, GetArenaForAllocation());
3688 }
_internal_mutable_session_handle()3689 inline std::string* ExtendSessionRequest::_internal_mutable_session_handle() {
3690
3691 return _impl_.session_handle_.Mutable(GetArenaForAllocation());
3692 }
release_session_handle()3693 inline std::string* ExtendSessionRequest::release_session_handle() {
3694 // @@protoc_insertion_point(field_release:tensorflow.ExtendSessionRequest.session_handle)
3695 return _impl_.session_handle_.Release();
3696 }
set_allocated_session_handle(std::string * session_handle)3697 inline void ExtendSessionRequest::set_allocated_session_handle(std::string* session_handle) {
3698 _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
3699 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3700 if (_impl_.session_handle_.IsDefault()) {
3701 _impl_.session_handle_.Set("", GetArenaForAllocation());
3702 }
3703 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3704 // @@protoc_insertion_point(field_set_allocated:tensorflow.ExtendSessionRequest.session_handle)
3705 }
3706
3707 // .tensorflow.GraphDef graph_def = 2;
_internal_has_graph_def()3708 inline bool ExtendSessionRequest::_internal_has_graph_def() const {
3709 return this != internal_default_instance() && _impl_.graph_def_ != nullptr;
3710 }
has_graph_def()3711 inline bool ExtendSessionRequest::has_graph_def() const {
3712 return _internal_has_graph_def();
3713 }
_internal_graph_def()3714 inline const ::tensorflow::GraphDef& ExtendSessionRequest::_internal_graph_def() const {
3715 const ::tensorflow::GraphDef* p = _impl_.graph_def_;
3716 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::GraphDef&>(
3717 ::tensorflow::_GraphDef_default_instance_);
3718 }
graph_def()3719 inline const ::tensorflow::GraphDef& ExtendSessionRequest::graph_def() const {
3720 // @@protoc_insertion_point(field_get:tensorflow.ExtendSessionRequest.graph_def)
3721 return _internal_graph_def();
3722 }
unsafe_arena_set_allocated_graph_def(::tensorflow::GraphDef * graph_def)3723 inline void ExtendSessionRequest::unsafe_arena_set_allocated_graph_def(
3724 ::tensorflow::GraphDef* graph_def) {
3725 if (GetArenaForAllocation() == nullptr) {
3726 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_def_);
3727 }
3728 _impl_.graph_def_ = graph_def;
3729 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ExtendSessionRequest.graph_def)
3730 }
release_graph_def()3731 inline ::tensorflow::GraphDef* ExtendSessionRequest::release_graph_def() {
3732
3733 ::tensorflow::GraphDef* temp = _impl_.graph_def_;
3734 _impl_.graph_def_ = nullptr;
3735 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
3736 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
3737 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3738 if (GetArenaForAllocation() == nullptr) { delete old; }
3739 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
3740 if (GetArenaForAllocation() != nullptr) {
3741 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3742 }
3743 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
3744 return temp;
3745 }
unsafe_arena_release_graph_def()3746 inline ::tensorflow::GraphDef* ExtendSessionRequest::unsafe_arena_release_graph_def() {
3747 // @@protoc_insertion_point(field_release:tensorflow.ExtendSessionRequest.graph_def)
3748
3749 ::tensorflow::GraphDef* temp = _impl_.graph_def_;
3750 _impl_.graph_def_ = nullptr;
3751 return temp;
3752 }
_internal_mutable_graph_def()3753 inline ::tensorflow::GraphDef* ExtendSessionRequest::_internal_mutable_graph_def() {
3754
3755 if (_impl_.graph_def_ == nullptr) {
3756 auto* p = CreateMaybeMessage<::tensorflow::GraphDef>(GetArenaForAllocation());
3757 _impl_.graph_def_ = p;
3758 }
3759 return _impl_.graph_def_;
3760 }
mutable_graph_def()3761 inline ::tensorflow::GraphDef* ExtendSessionRequest::mutable_graph_def() {
3762 ::tensorflow::GraphDef* _msg = _internal_mutable_graph_def();
3763 // @@protoc_insertion_point(field_mutable:tensorflow.ExtendSessionRequest.graph_def)
3764 return _msg;
3765 }
set_allocated_graph_def(::tensorflow::GraphDef * graph_def)3766 inline void ExtendSessionRequest::set_allocated_graph_def(::tensorflow::GraphDef* graph_def) {
3767 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
3768 if (message_arena == nullptr) {
3769 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.graph_def_);
3770 }
3771 if (graph_def) {
3772 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3773 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
3774 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(graph_def));
3775 if (message_arena != submessage_arena) {
3776 graph_def = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3777 message_arena, graph_def, submessage_arena);
3778 }
3779
3780 } else {
3781
3782 }
3783 _impl_.graph_def_ = graph_def;
3784 // @@protoc_insertion_point(field_set_allocated:tensorflow.ExtendSessionRequest.graph_def)
3785 }
3786
3787 // int64 current_graph_version = 3;
clear_current_graph_version()3788 inline void ExtendSessionRequest::clear_current_graph_version() {
3789 _impl_.current_graph_version_ = ::int64_t{0};
3790 }
_internal_current_graph_version()3791 inline ::int64_t ExtendSessionRequest::_internal_current_graph_version() const {
3792 return _impl_.current_graph_version_;
3793 }
current_graph_version()3794 inline ::int64_t ExtendSessionRequest::current_graph_version() const {
3795 // @@protoc_insertion_point(field_get:tensorflow.ExtendSessionRequest.current_graph_version)
3796 return _internal_current_graph_version();
3797 }
_internal_set_current_graph_version(::int64_t value)3798 inline void ExtendSessionRequest::_internal_set_current_graph_version(::int64_t value) {
3799
3800 _impl_.current_graph_version_ = value;
3801 }
set_current_graph_version(::int64_t value)3802 inline void ExtendSessionRequest::set_current_graph_version(::int64_t value) {
3803 _internal_set_current_graph_version(value);
3804 // @@protoc_insertion_point(field_set:tensorflow.ExtendSessionRequest.current_graph_version)
3805 }
3806
3807 // -------------------------------------------------------------------
3808
3809 // ExtendSessionResponse
3810
3811 // int64 new_graph_version = 4;
clear_new_graph_version()3812 inline void ExtendSessionResponse::clear_new_graph_version() {
3813 _impl_.new_graph_version_ = ::int64_t{0};
3814 }
_internal_new_graph_version()3815 inline ::int64_t ExtendSessionResponse::_internal_new_graph_version() const {
3816 return _impl_.new_graph_version_;
3817 }
new_graph_version()3818 inline ::int64_t ExtendSessionResponse::new_graph_version() const {
3819 // @@protoc_insertion_point(field_get:tensorflow.ExtendSessionResponse.new_graph_version)
3820 return _internal_new_graph_version();
3821 }
_internal_set_new_graph_version(::int64_t value)3822 inline void ExtendSessionResponse::_internal_set_new_graph_version(::int64_t value) {
3823
3824 _impl_.new_graph_version_ = value;
3825 }
set_new_graph_version(::int64_t value)3826 inline void ExtendSessionResponse::set_new_graph_version(::int64_t value) {
3827 _internal_set_new_graph_version(value);
3828 // @@protoc_insertion_point(field_set:tensorflow.ExtendSessionResponse.new_graph_version)
3829 }
3830
3831 // -------------------------------------------------------------------
3832
3833 // RunStepRequest
3834
3835 // string session_handle = 1;
clear_session_handle()3836 inline void RunStepRequest::clear_session_handle() {
3837 _impl_.session_handle_.ClearToEmpty();
3838 }
session_handle()3839 inline const std::string& RunStepRequest::session_handle() const {
3840 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.session_handle)
3841 return _internal_session_handle();
3842 }
3843 template <typename ArgT0, typename... ArgT>
3844 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)3845 void RunStepRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
3846
3847 _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3848 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.session_handle)
3849 }
mutable_session_handle()3850 inline std::string* RunStepRequest::mutable_session_handle() {
3851 std::string* _s = _internal_mutable_session_handle();
3852 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepRequest.session_handle)
3853 return _s;
3854 }
_internal_session_handle()3855 inline const std::string& RunStepRequest::_internal_session_handle() const {
3856 return _impl_.session_handle_.Get();
3857 }
_internal_set_session_handle(const std::string & value)3858 inline void RunStepRequest::_internal_set_session_handle(const std::string& value) {
3859
3860 _impl_.session_handle_.Set(value, GetArenaForAllocation());
3861 }
_internal_mutable_session_handle()3862 inline std::string* RunStepRequest::_internal_mutable_session_handle() {
3863
3864 return _impl_.session_handle_.Mutable(GetArenaForAllocation());
3865 }
release_session_handle()3866 inline std::string* RunStepRequest::release_session_handle() {
3867 // @@protoc_insertion_point(field_release:tensorflow.RunStepRequest.session_handle)
3868 return _impl_.session_handle_.Release();
3869 }
set_allocated_session_handle(std::string * session_handle)3870 inline void RunStepRequest::set_allocated_session_handle(std::string* session_handle) {
3871 _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
3872 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3873 if (_impl_.session_handle_.IsDefault()) {
3874 _impl_.session_handle_.Set("", GetArenaForAllocation());
3875 }
3876 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3877 // @@protoc_insertion_point(field_set_allocated:tensorflow.RunStepRequest.session_handle)
3878 }
3879
3880 // repeated .tensorflow.NamedTensorProto feed = 2;
_internal_feed_size()3881 inline int RunStepRequest::_internal_feed_size() const {
3882 return _impl_.feed_.size();
3883 }
feed_size()3884 inline int RunStepRequest::feed_size() const {
3885 return _internal_feed_size();
3886 }
mutable_feed(int index)3887 inline ::tensorflow::NamedTensorProto* RunStepRequest::mutable_feed(int index) {
3888 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepRequest.feed)
3889 return _impl_.feed_.Mutable(index);
3890 }
3891 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
mutable_feed()3892 RunStepRequest::mutable_feed() {
3893 // @@protoc_insertion_point(field_mutable_list:tensorflow.RunStepRequest.feed)
3894 return &_impl_.feed_;
3895 }
_internal_feed(int index)3896 inline const ::tensorflow::NamedTensorProto& RunStepRequest::_internal_feed(int index) const {
3897 return _impl_.feed_.Get(index);
3898 }
feed(int index)3899 inline const ::tensorflow::NamedTensorProto& RunStepRequest::feed(int index) const {
3900 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.feed)
3901 return _internal_feed(index);
3902 }
_internal_add_feed()3903 inline ::tensorflow::NamedTensorProto* RunStepRequest::_internal_add_feed() {
3904 return _impl_.feed_.Add();
3905 }
add_feed()3906 inline ::tensorflow::NamedTensorProto* RunStepRequest::add_feed() {
3907 ::tensorflow::NamedTensorProto* _add = _internal_add_feed();
3908 // @@protoc_insertion_point(field_add:tensorflow.RunStepRequest.feed)
3909 return _add;
3910 }
3911 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
feed()3912 RunStepRequest::feed() const {
3913 // @@protoc_insertion_point(field_list:tensorflow.RunStepRequest.feed)
3914 return _impl_.feed_;
3915 }
3916
3917 // repeated string fetch = 3;
_internal_fetch_size()3918 inline int RunStepRequest::_internal_fetch_size() const {
3919 return _impl_.fetch_.size();
3920 }
fetch_size()3921 inline int RunStepRequest::fetch_size() const {
3922 return _internal_fetch_size();
3923 }
clear_fetch()3924 inline void RunStepRequest::clear_fetch() {
3925 _impl_.fetch_.Clear();
3926 }
add_fetch()3927 inline std::string* RunStepRequest::add_fetch() {
3928 std::string* _s = _internal_add_fetch();
3929 // @@protoc_insertion_point(field_add_mutable:tensorflow.RunStepRequest.fetch)
3930 return _s;
3931 }
_internal_fetch(int index)3932 inline const std::string& RunStepRequest::_internal_fetch(int index) const {
3933 return _impl_.fetch_.Get(index);
3934 }
fetch(int index)3935 inline const std::string& RunStepRequest::fetch(int index) const {
3936 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.fetch)
3937 return _internal_fetch(index);
3938 }
mutable_fetch(int index)3939 inline std::string* RunStepRequest::mutable_fetch(int index) {
3940 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepRequest.fetch)
3941 return _impl_.fetch_.Mutable(index);
3942 }
set_fetch(int index,const std::string & value)3943 inline void RunStepRequest::set_fetch(int index, const std::string& value) {
3944 _impl_.fetch_.Mutable(index)->assign(value);
3945 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.fetch)
3946 }
set_fetch(int index,std::string && value)3947 inline void RunStepRequest::set_fetch(int index, std::string&& value) {
3948 _impl_.fetch_.Mutable(index)->assign(std::move(value));
3949 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.fetch)
3950 }
set_fetch(int index,const char * value)3951 inline void RunStepRequest::set_fetch(int index, const char* value) {
3952 GOOGLE_DCHECK(value != nullptr);
3953 _impl_.fetch_.Mutable(index)->assign(value);
3954 // @@protoc_insertion_point(field_set_char:tensorflow.RunStepRequest.fetch)
3955 }
set_fetch(int index,const char * value,size_t size)3956 inline void RunStepRequest::set_fetch(int index, const char* value, size_t size) {
3957 _impl_.fetch_.Mutable(index)->assign(
3958 reinterpret_cast<const char*>(value), size);
3959 // @@protoc_insertion_point(field_set_pointer:tensorflow.RunStepRequest.fetch)
3960 }
_internal_add_fetch()3961 inline std::string* RunStepRequest::_internal_add_fetch() {
3962 return _impl_.fetch_.Add();
3963 }
add_fetch(const std::string & value)3964 inline void RunStepRequest::add_fetch(const std::string& value) {
3965 _impl_.fetch_.Add()->assign(value);
3966 // @@protoc_insertion_point(field_add:tensorflow.RunStepRequest.fetch)
3967 }
add_fetch(std::string && value)3968 inline void RunStepRequest::add_fetch(std::string&& value) {
3969 _impl_.fetch_.Add(std::move(value));
3970 // @@protoc_insertion_point(field_add:tensorflow.RunStepRequest.fetch)
3971 }
add_fetch(const char * value)3972 inline void RunStepRequest::add_fetch(const char* value) {
3973 GOOGLE_DCHECK(value != nullptr);
3974 _impl_.fetch_.Add()->assign(value);
3975 // @@protoc_insertion_point(field_add_char:tensorflow.RunStepRequest.fetch)
3976 }
add_fetch(const char * value,size_t size)3977 inline void RunStepRequest::add_fetch(const char* value, size_t size) {
3978 _impl_.fetch_.Add()->assign(reinterpret_cast<const char*>(value), size);
3979 // @@protoc_insertion_point(field_add_pointer:tensorflow.RunStepRequest.fetch)
3980 }
3981 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
fetch()3982 RunStepRequest::fetch() const {
3983 // @@protoc_insertion_point(field_list:tensorflow.RunStepRequest.fetch)
3984 return _impl_.fetch_;
3985 }
3986 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_fetch()3987 RunStepRequest::mutable_fetch() {
3988 // @@protoc_insertion_point(field_mutable_list:tensorflow.RunStepRequest.fetch)
3989 return &_impl_.fetch_;
3990 }
3991
3992 // repeated string target = 4;
_internal_target_size()3993 inline int RunStepRequest::_internal_target_size() const {
3994 return _impl_.target_.size();
3995 }
target_size()3996 inline int RunStepRequest::target_size() const {
3997 return _internal_target_size();
3998 }
clear_target()3999 inline void RunStepRequest::clear_target() {
4000 _impl_.target_.Clear();
4001 }
add_target()4002 inline std::string* RunStepRequest::add_target() {
4003 std::string* _s = _internal_add_target();
4004 // @@protoc_insertion_point(field_add_mutable:tensorflow.RunStepRequest.target)
4005 return _s;
4006 }
_internal_target(int index)4007 inline const std::string& RunStepRequest::_internal_target(int index) const {
4008 return _impl_.target_.Get(index);
4009 }
target(int index)4010 inline const std::string& RunStepRequest::target(int index) const {
4011 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.target)
4012 return _internal_target(index);
4013 }
mutable_target(int index)4014 inline std::string* RunStepRequest::mutable_target(int index) {
4015 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepRequest.target)
4016 return _impl_.target_.Mutable(index);
4017 }
set_target(int index,const std::string & value)4018 inline void RunStepRequest::set_target(int index, const std::string& value) {
4019 _impl_.target_.Mutable(index)->assign(value);
4020 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.target)
4021 }
set_target(int index,std::string && value)4022 inline void RunStepRequest::set_target(int index, std::string&& value) {
4023 _impl_.target_.Mutable(index)->assign(std::move(value));
4024 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.target)
4025 }
set_target(int index,const char * value)4026 inline void RunStepRequest::set_target(int index, const char* value) {
4027 GOOGLE_DCHECK(value != nullptr);
4028 _impl_.target_.Mutable(index)->assign(value);
4029 // @@protoc_insertion_point(field_set_char:tensorflow.RunStepRequest.target)
4030 }
set_target(int index,const char * value,size_t size)4031 inline void RunStepRequest::set_target(int index, const char* value, size_t size) {
4032 _impl_.target_.Mutable(index)->assign(
4033 reinterpret_cast<const char*>(value), size);
4034 // @@protoc_insertion_point(field_set_pointer:tensorflow.RunStepRequest.target)
4035 }
_internal_add_target()4036 inline std::string* RunStepRequest::_internal_add_target() {
4037 return _impl_.target_.Add();
4038 }
add_target(const std::string & value)4039 inline void RunStepRequest::add_target(const std::string& value) {
4040 _impl_.target_.Add()->assign(value);
4041 // @@protoc_insertion_point(field_add:tensorflow.RunStepRequest.target)
4042 }
add_target(std::string && value)4043 inline void RunStepRequest::add_target(std::string&& value) {
4044 _impl_.target_.Add(std::move(value));
4045 // @@protoc_insertion_point(field_add:tensorflow.RunStepRequest.target)
4046 }
add_target(const char * value)4047 inline void RunStepRequest::add_target(const char* value) {
4048 GOOGLE_DCHECK(value != nullptr);
4049 _impl_.target_.Add()->assign(value);
4050 // @@protoc_insertion_point(field_add_char:tensorflow.RunStepRequest.target)
4051 }
add_target(const char * value,size_t size)4052 inline void RunStepRequest::add_target(const char* value, size_t size) {
4053 _impl_.target_.Add()->assign(reinterpret_cast<const char*>(value), size);
4054 // @@protoc_insertion_point(field_add_pointer:tensorflow.RunStepRequest.target)
4055 }
4056 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
target()4057 RunStepRequest::target() const {
4058 // @@protoc_insertion_point(field_list:tensorflow.RunStepRequest.target)
4059 return _impl_.target_;
4060 }
4061 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_target()4062 RunStepRequest::mutable_target() {
4063 // @@protoc_insertion_point(field_mutable_list:tensorflow.RunStepRequest.target)
4064 return &_impl_.target_;
4065 }
4066
4067 // .tensorflow.RunOptions options = 5;
_internal_has_options()4068 inline bool RunStepRequest::_internal_has_options() const {
4069 return this != internal_default_instance() && _impl_.options_ != nullptr;
4070 }
has_options()4071 inline bool RunStepRequest::has_options() const {
4072 return _internal_has_options();
4073 }
_internal_options()4074 inline const ::tensorflow::RunOptions& RunStepRequest::_internal_options() const {
4075 const ::tensorflow::RunOptions* p = _impl_.options_;
4076 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::RunOptions&>(
4077 ::tensorflow::_RunOptions_default_instance_);
4078 }
options()4079 inline const ::tensorflow::RunOptions& RunStepRequest::options() const {
4080 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.options)
4081 return _internal_options();
4082 }
unsafe_arena_set_allocated_options(::tensorflow::RunOptions * options)4083 inline void RunStepRequest::unsafe_arena_set_allocated_options(
4084 ::tensorflow::RunOptions* options) {
4085 if (GetArenaForAllocation() == nullptr) {
4086 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
4087 }
4088 _impl_.options_ = options;
4089 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RunStepRequest.options)
4090 }
release_options()4091 inline ::tensorflow::RunOptions* RunStepRequest::release_options() {
4092
4093 ::tensorflow::RunOptions* temp = _impl_.options_;
4094 _impl_.options_ = nullptr;
4095 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4096 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4097 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4098 if (GetArenaForAllocation() == nullptr) { delete old; }
4099 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4100 if (GetArenaForAllocation() != nullptr) {
4101 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4102 }
4103 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4104 return temp;
4105 }
unsafe_arena_release_options()4106 inline ::tensorflow::RunOptions* RunStepRequest::unsafe_arena_release_options() {
4107 // @@protoc_insertion_point(field_release:tensorflow.RunStepRequest.options)
4108
4109 ::tensorflow::RunOptions* temp = _impl_.options_;
4110 _impl_.options_ = nullptr;
4111 return temp;
4112 }
_internal_mutable_options()4113 inline ::tensorflow::RunOptions* RunStepRequest::_internal_mutable_options() {
4114
4115 if (_impl_.options_ == nullptr) {
4116 auto* p = CreateMaybeMessage<::tensorflow::RunOptions>(GetArenaForAllocation());
4117 _impl_.options_ = p;
4118 }
4119 return _impl_.options_;
4120 }
mutable_options()4121 inline ::tensorflow::RunOptions* RunStepRequest::mutable_options() {
4122 ::tensorflow::RunOptions* _msg = _internal_mutable_options();
4123 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepRequest.options)
4124 return _msg;
4125 }
set_allocated_options(::tensorflow::RunOptions * options)4126 inline void RunStepRequest::set_allocated_options(::tensorflow::RunOptions* options) {
4127 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4128 if (message_arena == nullptr) {
4129 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.options_);
4130 }
4131 if (options) {
4132 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4133 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4134 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options));
4135 if (message_arena != submessage_arena) {
4136 options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4137 message_arena, options, submessage_arena);
4138 }
4139
4140 } else {
4141
4142 }
4143 _impl_.options_ = options;
4144 // @@protoc_insertion_point(field_set_allocated:tensorflow.RunStepRequest.options)
4145 }
4146
4147 // string partial_run_handle = 6;
clear_partial_run_handle()4148 inline void RunStepRequest::clear_partial_run_handle() {
4149 _impl_.partial_run_handle_.ClearToEmpty();
4150 }
partial_run_handle()4151 inline const std::string& RunStepRequest::partial_run_handle() const {
4152 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.partial_run_handle)
4153 return _internal_partial_run_handle();
4154 }
4155 template <typename ArgT0, typename... ArgT>
4156 inline PROTOBUF_ALWAYS_INLINE
set_partial_run_handle(ArgT0 && arg0,ArgT...args)4157 void RunStepRequest::set_partial_run_handle(ArgT0&& arg0, ArgT... args) {
4158
4159 _impl_.partial_run_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4160 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.partial_run_handle)
4161 }
mutable_partial_run_handle()4162 inline std::string* RunStepRequest::mutable_partial_run_handle() {
4163 std::string* _s = _internal_mutable_partial_run_handle();
4164 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepRequest.partial_run_handle)
4165 return _s;
4166 }
_internal_partial_run_handle()4167 inline const std::string& RunStepRequest::_internal_partial_run_handle() const {
4168 return _impl_.partial_run_handle_.Get();
4169 }
_internal_set_partial_run_handle(const std::string & value)4170 inline void RunStepRequest::_internal_set_partial_run_handle(const std::string& value) {
4171
4172 _impl_.partial_run_handle_.Set(value, GetArenaForAllocation());
4173 }
_internal_mutable_partial_run_handle()4174 inline std::string* RunStepRequest::_internal_mutable_partial_run_handle() {
4175
4176 return _impl_.partial_run_handle_.Mutable(GetArenaForAllocation());
4177 }
release_partial_run_handle()4178 inline std::string* RunStepRequest::release_partial_run_handle() {
4179 // @@protoc_insertion_point(field_release:tensorflow.RunStepRequest.partial_run_handle)
4180 return _impl_.partial_run_handle_.Release();
4181 }
set_allocated_partial_run_handle(std::string * partial_run_handle)4182 inline void RunStepRequest::set_allocated_partial_run_handle(std::string* partial_run_handle) {
4183 _impl_.partial_run_handle_.SetAllocated(partial_run_handle, GetArenaForAllocation());
4184 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4185 if (_impl_.partial_run_handle_.IsDefault()) {
4186 _impl_.partial_run_handle_.Set("", GetArenaForAllocation());
4187 }
4188 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4189 // @@protoc_insertion_point(field_set_allocated:tensorflow.RunStepRequest.partial_run_handle)
4190 }
4191
4192 // bool store_errors_in_response_body = 7;
clear_store_errors_in_response_body()4193 inline void RunStepRequest::clear_store_errors_in_response_body() {
4194 _impl_.store_errors_in_response_body_ = false;
4195 }
_internal_store_errors_in_response_body()4196 inline bool RunStepRequest::_internal_store_errors_in_response_body() const {
4197 return _impl_.store_errors_in_response_body_;
4198 }
store_errors_in_response_body()4199 inline bool RunStepRequest::store_errors_in_response_body() const {
4200 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.store_errors_in_response_body)
4201 return _internal_store_errors_in_response_body();
4202 }
_internal_set_store_errors_in_response_body(bool value)4203 inline void RunStepRequest::_internal_set_store_errors_in_response_body(bool value) {
4204
4205 _impl_.store_errors_in_response_body_ = value;
4206 }
set_store_errors_in_response_body(bool value)4207 inline void RunStepRequest::set_store_errors_in_response_body(bool value) {
4208 _internal_set_store_errors_in_response_body(value);
4209 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.store_errors_in_response_body)
4210 }
4211
4212 // int64 request_id = 8;
clear_request_id()4213 inline void RunStepRequest::clear_request_id() {
4214 _impl_.request_id_ = ::int64_t{0};
4215 }
_internal_request_id()4216 inline ::int64_t RunStepRequest::_internal_request_id() const {
4217 return _impl_.request_id_;
4218 }
request_id()4219 inline ::int64_t RunStepRequest::request_id() const {
4220 // @@protoc_insertion_point(field_get:tensorflow.RunStepRequest.request_id)
4221 return _internal_request_id();
4222 }
_internal_set_request_id(::int64_t value)4223 inline void RunStepRequest::_internal_set_request_id(::int64_t value) {
4224
4225 _impl_.request_id_ = value;
4226 }
set_request_id(::int64_t value)4227 inline void RunStepRequest::set_request_id(::int64_t value) {
4228 _internal_set_request_id(value);
4229 // @@protoc_insertion_point(field_set:tensorflow.RunStepRequest.request_id)
4230 }
4231
4232 // -------------------------------------------------------------------
4233
4234 // RunStepResponse
4235
4236 // repeated .tensorflow.NamedTensorProto tensor = 1;
_internal_tensor_size()4237 inline int RunStepResponse::_internal_tensor_size() const {
4238 return _impl_.tensor_.size();
4239 }
tensor_size()4240 inline int RunStepResponse::tensor_size() const {
4241 return _internal_tensor_size();
4242 }
mutable_tensor(int index)4243 inline ::tensorflow::NamedTensorProto* RunStepResponse::mutable_tensor(int index) {
4244 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepResponse.tensor)
4245 return _impl_.tensor_.Mutable(index);
4246 }
4247 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >*
mutable_tensor()4248 RunStepResponse::mutable_tensor() {
4249 // @@protoc_insertion_point(field_mutable_list:tensorflow.RunStepResponse.tensor)
4250 return &_impl_.tensor_;
4251 }
_internal_tensor(int index)4252 inline const ::tensorflow::NamedTensorProto& RunStepResponse::_internal_tensor(int index) const {
4253 return _impl_.tensor_.Get(index);
4254 }
tensor(int index)4255 inline const ::tensorflow::NamedTensorProto& RunStepResponse::tensor(int index) const {
4256 // @@protoc_insertion_point(field_get:tensorflow.RunStepResponse.tensor)
4257 return _internal_tensor(index);
4258 }
_internal_add_tensor()4259 inline ::tensorflow::NamedTensorProto* RunStepResponse::_internal_add_tensor() {
4260 return _impl_.tensor_.Add();
4261 }
add_tensor()4262 inline ::tensorflow::NamedTensorProto* RunStepResponse::add_tensor() {
4263 ::tensorflow::NamedTensorProto* _add = _internal_add_tensor();
4264 // @@protoc_insertion_point(field_add:tensorflow.RunStepResponse.tensor)
4265 return _add;
4266 }
4267 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::NamedTensorProto >&
tensor()4268 RunStepResponse::tensor() const {
4269 // @@protoc_insertion_point(field_list:tensorflow.RunStepResponse.tensor)
4270 return _impl_.tensor_;
4271 }
4272
4273 // .tensorflow.RunMetadata metadata = 2;
_internal_has_metadata()4274 inline bool RunStepResponse::_internal_has_metadata() const {
4275 return this != internal_default_instance() && _impl_.metadata_ != nullptr;
4276 }
has_metadata()4277 inline bool RunStepResponse::has_metadata() const {
4278 return _internal_has_metadata();
4279 }
_internal_metadata()4280 inline const ::tensorflow::RunMetadata& RunStepResponse::_internal_metadata() const {
4281 const ::tensorflow::RunMetadata* p = _impl_.metadata_;
4282 return p != nullptr ? *p : reinterpret_cast<const ::tensorflow::RunMetadata&>(
4283 ::tensorflow::_RunMetadata_default_instance_);
4284 }
metadata()4285 inline const ::tensorflow::RunMetadata& RunStepResponse::metadata() const {
4286 // @@protoc_insertion_point(field_get:tensorflow.RunStepResponse.metadata)
4287 return _internal_metadata();
4288 }
unsafe_arena_set_allocated_metadata(::tensorflow::RunMetadata * metadata)4289 inline void RunStepResponse::unsafe_arena_set_allocated_metadata(
4290 ::tensorflow::RunMetadata* metadata) {
4291 if (GetArenaForAllocation() == nullptr) {
4292 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
4293 }
4294 _impl_.metadata_ = metadata;
4295 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.RunStepResponse.metadata)
4296 }
release_metadata()4297 inline ::tensorflow::RunMetadata* RunStepResponse::release_metadata() {
4298
4299 ::tensorflow::RunMetadata* temp = _impl_.metadata_;
4300 _impl_.metadata_ = nullptr;
4301 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
4302 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
4303 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4304 if (GetArenaForAllocation() == nullptr) { delete old; }
4305 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
4306 if (GetArenaForAllocation() != nullptr) {
4307 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4308 }
4309 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
4310 return temp;
4311 }
unsafe_arena_release_metadata()4312 inline ::tensorflow::RunMetadata* RunStepResponse::unsafe_arena_release_metadata() {
4313 // @@protoc_insertion_point(field_release:tensorflow.RunStepResponse.metadata)
4314
4315 ::tensorflow::RunMetadata* temp = _impl_.metadata_;
4316 _impl_.metadata_ = nullptr;
4317 return temp;
4318 }
_internal_mutable_metadata()4319 inline ::tensorflow::RunMetadata* RunStepResponse::_internal_mutable_metadata() {
4320
4321 if (_impl_.metadata_ == nullptr) {
4322 auto* p = CreateMaybeMessage<::tensorflow::RunMetadata>(GetArenaForAllocation());
4323 _impl_.metadata_ = p;
4324 }
4325 return _impl_.metadata_;
4326 }
mutable_metadata()4327 inline ::tensorflow::RunMetadata* RunStepResponse::mutable_metadata() {
4328 ::tensorflow::RunMetadata* _msg = _internal_mutable_metadata();
4329 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepResponse.metadata)
4330 return _msg;
4331 }
set_allocated_metadata(::tensorflow::RunMetadata * metadata)4332 inline void RunStepResponse::set_allocated_metadata(::tensorflow::RunMetadata* metadata) {
4333 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
4334 if (message_arena == nullptr) {
4335 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.metadata_);
4336 }
4337 if (metadata) {
4338 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4339 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
4340 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(metadata));
4341 if (message_arena != submessage_arena) {
4342 metadata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4343 message_arena, metadata, submessage_arena);
4344 }
4345
4346 } else {
4347
4348 }
4349 _impl_.metadata_ = metadata;
4350 // @@protoc_insertion_point(field_set_allocated:tensorflow.RunStepResponse.metadata)
4351 }
4352
4353 // .tensorflow.error.Code status_code = 3;
clear_status_code()4354 inline void RunStepResponse::clear_status_code() {
4355 _impl_.status_code_ = 0;
4356 }
_internal_status_code()4357 inline ::tensorflow::error::Code RunStepResponse::_internal_status_code() const {
4358 return static_cast< ::tensorflow::error::Code >(_impl_.status_code_);
4359 }
status_code()4360 inline ::tensorflow::error::Code RunStepResponse::status_code() const {
4361 // @@protoc_insertion_point(field_get:tensorflow.RunStepResponse.status_code)
4362 return _internal_status_code();
4363 }
_internal_set_status_code(::tensorflow::error::Code value)4364 inline void RunStepResponse::_internal_set_status_code(::tensorflow::error::Code value) {
4365
4366 _impl_.status_code_ = value;
4367 }
set_status_code(::tensorflow::error::Code value)4368 inline void RunStepResponse::set_status_code(::tensorflow::error::Code value) {
4369 _internal_set_status_code(value);
4370 // @@protoc_insertion_point(field_set:tensorflow.RunStepResponse.status_code)
4371 }
4372
4373 // string status_error_message = 4;
clear_status_error_message()4374 inline void RunStepResponse::clear_status_error_message() {
4375 _impl_.status_error_message_.ClearToEmpty();
4376 }
status_error_message()4377 inline const std::string& RunStepResponse::status_error_message() const {
4378 // @@protoc_insertion_point(field_get:tensorflow.RunStepResponse.status_error_message)
4379 return _internal_status_error_message();
4380 }
4381 template <typename ArgT0, typename... ArgT>
4382 inline PROTOBUF_ALWAYS_INLINE
set_status_error_message(ArgT0 && arg0,ArgT...args)4383 void RunStepResponse::set_status_error_message(ArgT0&& arg0, ArgT... args) {
4384
4385 _impl_.status_error_message_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4386 // @@protoc_insertion_point(field_set:tensorflow.RunStepResponse.status_error_message)
4387 }
mutable_status_error_message()4388 inline std::string* RunStepResponse::mutable_status_error_message() {
4389 std::string* _s = _internal_mutable_status_error_message();
4390 // @@protoc_insertion_point(field_mutable:tensorflow.RunStepResponse.status_error_message)
4391 return _s;
4392 }
_internal_status_error_message()4393 inline const std::string& RunStepResponse::_internal_status_error_message() const {
4394 return _impl_.status_error_message_.Get();
4395 }
_internal_set_status_error_message(const std::string & value)4396 inline void RunStepResponse::_internal_set_status_error_message(const std::string& value) {
4397
4398 _impl_.status_error_message_.Set(value, GetArenaForAllocation());
4399 }
_internal_mutable_status_error_message()4400 inline std::string* RunStepResponse::_internal_mutable_status_error_message() {
4401
4402 return _impl_.status_error_message_.Mutable(GetArenaForAllocation());
4403 }
release_status_error_message()4404 inline std::string* RunStepResponse::release_status_error_message() {
4405 // @@protoc_insertion_point(field_release:tensorflow.RunStepResponse.status_error_message)
4406 return _impl_.status_error_message_.Release();
4407 }
set_allocated_status_error_message(std::string * status_error_message)4408 inline void RunStepResponse::set_allocated_status_error_message(std::string* status_error_message) {
4409 _impl_.status_error_message_.SetAllocated(status_error_message, GetArenaForAllocation());
4410 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4411 if (_impl_.status_error_message_.IsDefault()) {
4412 _impl_.status_error_message_.Set("", GetArenaForAllocation());
4413 }
4414 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4415 // @@protoc_insertion_point(field_set_allocated:tensorflow.RunStepResponse.status_error_message)
4416 }
4417
4418 // -------------------------------------------------------------------
4419
4420 // PartialRunSetupRequest
4421
4422 // string session_handle = 1;
clear_session_handle()4423 inline void PartialRunSetupRequest::clear_session_handle() {
4424 _impl_.session_handle_.ClearToEmpty();
4425 }
session_handle()4426 inline const std::string& PartialRunSetupRequest::session_handle() const {
4427 // @@protoc_insertion_point(field_get:tensorflow.PartialRunSetupRequest.session_handle)
4428 return _internal_session_handle();
4429 }
4430 template <typename ArgT0, typename... ArgT>
4431 inline PROTOBUF_ALWAYS_INLINE
set_session_handle(ArgT0 && arg0,ArgT...args)4432 void PartialRunSetupRequest::set_session_handle(ArgT0&& arg0, ArgT... args) {
4433
4434 _impl_.session_handle_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
4435 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.session_handle)
4436 }
mutable_session_handle()4437 inline std::string* PartialRunSetupRequest::mutable_session_handle() {
4438 std::string* _s = _internal_mutable_session_handle();
4439 // @@protoc_insertion_point(field_mutable:tensorflow.PartialRunSetupRequest.session_handle)
4440 return _s;
4441 }
_internal_session_handle()4442 inline const std::string& PartialRunSetupRequest::_internal_session_handle() const {
4443 return _impl_.session_handle_.Get();
4444 }
_internal_set_session_handle(const std::string & value)4445 inline void PartialRunSetupRequest::_internal_set_session_handle(const std::string& value) {
4446
4447 _impl_.session_handle_.Set(value, GetArenaForAllocation());
4448 }
_internal_mutable_session_handle()4449 inline std::string* PartialRunSetupRequest::_internal_mutable_session_handle() {
4450
4451 return _impl_.session_handle_.Mutable(GetArenaForAllocation());
4452 }
release_session_handle()4453 inline std::string* PartialRunSetupRequest::release_session_handle() {
4454 // @@protoc_insertion_point(field_release:tensorflow.PartialRunSetupRequest.session_handle)
4455 return _impl_.session_handle_.Release();
4456 }
set_allocated_session_handle(std::string * session_handle)4457 inline void PartialRunSetupRequest::set_allocated_session_handle(std::string* session_handle) {
4458 _impl_.session_handle_.SetAllocated(session_handle, GetArenaForAllocation());
4459 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4460 if (_impl_.session_handle_.IsDefault()) {
4461 _impl_.session_handle_.Set("", GetArenaForAllocation());
4462 }
4463 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4464 // @@protoc_insertion_point(field_set_allocated:tensorflow.PartialRunSetupRequest.session_handle)
4465 }
4466
4467 // repeated string feed = 2;
_internal_feed_size()4468 inline int PartialRunSetupRequest::_internal_feed_size() const {
4469 return _impl_.feed_.size();
4470 }
feed_size()4471 inline int PartialRunSetupRequest::feed_size() const {
4472 return _internal_feed_size();
4473 }
clear_feed()4474 inline void PartialRunSetupRequest::clear_feed() {
4475 _impl_.feed_.Clear();
4476 }
add_feed()4477 inline std::string* PartialRunSetupRequest::add_feed() {
4478 std::string* _s = _internal_add_feed();
4479 // @@protoc_insertion_point(field_add_mutable:tensorflow.PartialRunSetupRequest.feed)
4480 return _s;
4481 }
_internal_feed(int index)4482 inline const std::string& PartialRunSetupRequest::_internal_feed(int index) const {
4483 return _impl_.feed_.Get(index);
4484 }
feed(int index)4485 inline const std::string& PartialRunSetupRequest::feed(int index) const {
4486 // @@protoc_insertion_point(field_get:tensorflow.PartialRunSetupRequest.feed)
4487 return _internal_feed(index);
4488 }
mutable_feed(int index)4489 inline std::string* PartialRunSetupRequest::mutable_feed(int index) {
4490 // @@protoc_insertion_point(field_mutable:tensorflow.PartialRunSetupRequest.feed)
4491 return _impl_.feed_.Mutable(index);
4492 }
set_feed(int index,const std::string & value)4493 inline void PartialRunSetupRequest::set_feed(int index, const std::string& value) {
4494 _impl_.feed_.Mutable(index)->assign(value);
4495 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.feed)
4496 }
set_feed(int index,std::string && value)4497 inline void PartialRunSetupRequest::set_feed(int index, std::string&& value) {
4498 _impl_.feed_.Mutable(index)->assign(std::move(value));
4499 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.feed)
4500 }
set_feed(int index,const char * value)4501 inline void PartialRunSetupRequest::set_feed(int index, const char* value) {
4502 GOOGLE_DCHECK(value != nullptr);
4503 _impl_.feed_.Mutable(index)->assign(value);
4504 // @@protoc_insertion_point(field_set_char:tensorflow.PartialRunSetupRequest.feed)
4505 }
set_feed(int index,const char * value,size_t size)4506 inline void PartialRunSetupRequest::set_feed(int index, const char* value, size_t size) {
4507 _impl_.feed_.Mutable(index)->assign(
4508 reinterpret_cast<const char*>(value), size);
4509 // @@protoc_insertion_point(field_set_pointer:tensorflow.PartialRunSetupRequest.feed)
4510 }
_internal_add_feed()4511 inline std::string* PartialRunSetupRequest::_internal_add_feed() {
4512 return _impl_.feed_.Add();
4513 }
add_feed(const std::string & value)4514 inline void PartialRunSetupRequest::add_feed(const std::string& value) {
4515 _impl_.feed_.Add()->assign(value);
4516 // @@protoc_insertion_point(field_add:tensorflow.PartialRunSetupRequest.feed)
4517 }
add_feed(std::string && value)4518 inline void PartialRunSetupRequest::add_feed(std::string&& value) {
4519 _impl_.feed_.Add(std::move(value));
4520 // @@protoc_insertion_point(field_add:tensorflow.PartialRunSetupRequest.feed)
4521 }
add_feed(const char * value)4522 inline void PartialRunSetupRequest::add_feed(const char* value) {
4523 GOOGLE_DCHECK(value != nullptr);
4524 _impl_.feed_.Add()->assign(value);
4525 // @@protoc_insertion_point(field_add_char:tensorflow.PartialRunSetupRequest.feed)
4526 }
add_feed(const char * value,size_t size)4527 inline void PartialRunSetupRequest::add_feed(const char* value, size_t size) {
4528 _impl_.feed_.Add()->assign(reinterpret_cast<const char*>(value), size);
4529 // @@protoc_insertion_point(field_add_pointer:tensorflow.PartialRunSetupRequest.feed)
4530 }
4531 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
feed()4532 PartialRunSetupRequest::feed() const {
4533 // @@protoc_insertion_point(field_list:tensorflow.PartialRunSetupRequest.feed)
4534 return _impl_.feed_;
4535 }
4536 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_feed()4537 PartialRunSetupRequest::mutable_feed() {
4538 // @@protoc_insertion_point(field_mutable_list:tensorflow.PartialRunSetupRequest.feed)
4539 return &_impl_.feed_;
4540 }
4541
4542 // repeated string fetch = 3;
_internal_fetch_size()4543 inline int PartialRunSetupRequest::_internal_fetch_size() const {
4544 return _impl_.fetch_.size();
4545 }
fetch_size()4546 inline int PartialRunSetupRequest::fetch_size() const {
4547 return _internal_fetch_size();
4548 }
clear_fetch()4549 inline void PartialRunSetupRequest::clear_fetch() {
4550 _impl_.fetch_.Clear();
4551 }
add_fetch()4552 inline std::string* PartialRunSetupRequest::add_fetch() {
4553 std::string* _s = _internal_add_fetch();
4554 // @@protoc_insertion_point(field_add_mutable:tensorflow.PartialRunSetupRequest.fetch)
4555 return _s;
4556 }
_internal_fetch(int index)4557 inline const std::string& PartialRunSetupRequest::_internal_fetch(int index) const {
4558 return _impl_.fetch_.Get(index);
4559 }
fetch(int index)4560 inline const std::string& PartialRunSetupRequest::fetch(int index) const {
4561 // @@protoc_insertion_point(field_get:tensorflow.PartialRunSetupRequest.fetch)
4562 return _internal_fetch(index);
4563 }
mutable_fetch(int index)4564 inline std::string* PartialRunSetupRequest::mutable_fetch(int index) {
4565 // @@protoc_insertion_point(field_mutable:tensorflow.PartialRunSetupRequest.fetch)
4566 return _impl_.fetch_.Mutable(index);
4567 }
set_fetch(int index,const std::string & value)4568 inline void PartialRunSetupRequest::set_fetch(int index, const std::string& value) {
4569 _impl_.fetch_.Mutable(index)->assign(value);
4570 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.fetch)
4571 }
set_fetch(int index,std::string && value)4572 inline void PartialRunSetupRequest::set_fetch(int index, std::string&& value) {
4573 _impl_.fetch_.Mutable(index)->assign(std::move(value));
4574 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.fetch)
4575 }
set_fetch(int index,const char * value)4576 inline void PartialRunSetupRequest::set_fetch(int index, const char* value) {
4577 GOOGLE_DCHECK(value != nullptr);
4578 _impl_.fetch_.Mutable(index)->assign(value);
4579 // @@protoc_insertion_point(field_set_char:tensorflow.PartialRunSetupRequest.fetch)
4580 }
set_fetch(int index,const char * value,size_t size)4581 inline void PartialRunSetupRequest::set_fetch(int index, const char* value, size_t size) {
4582 _impl_.fetch_.Mutable(index)->assign(
4583 reinterpret_cast<const char*>(value), size);
4584 // @@protoc_insertion_point(field_set_pointer:tensorflow.PartialRunSetupRequest.fetch)
4585 }
_internal_add_fetch()4586 inline std::string* PartialRunSetupRequest::_internal_add_fetch() {
4587 return _impl_.fetch_.Add();
4588 }
add_fetch(const std::string & value)4589 inline void PartialRunSetupRequest::add_fetch(const std::string& value) {
4590 _impl_.fetch_.Add()->assign(value);
4591 // @@protoc_insertion_point(field_add:tensorflow.PartialRunSetupRequest.fetch)
4592 }
add_fetch(std::string && value)4593 inline void PartialRunSetupRequest::add_fetch(std::string&& value) {
4594 _impl_.fetch_.Add(std::move(value));
4595 // @@protoc_insertion_point(field_add:tensorflow.PartialRunSetupRequest.fetch)
4596 }
add_fetch(const char * value)4597 inline void PartialRunSetupRequest::add_fetch(const char* value) {
4598 GOOGLE_DCHECK(value != nullptr);
4599 _impl_.fetch_.Add()->assign(value);
4600 // @@protoc_insertion_point(field_add_char:tensorflow.PartialRunSetupRequest.fetch)
4601 }
add_fetch(const char * value,size_t size)4602 inline void PartialRunSetupRequest::add_fetch(const char* value, size_t size) {
4603 _impl_.fetch_.Add()->assign(reinterpret_cast<const char*>(value), size);
4604 // @@protoc_insertion_point(field_add_pointer:tensorflow.PartialRunSetupRequest.fetch)
4605 }
4606 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
fetch()4607 PartialRunSetupRequest::fetch() const {
4608 // @@protoc_insertion_point(field_list:tensorflow.PartialRunSetupRequest.fetch)
4609 return _impl_.fetch_;
4610 }
4611 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_fetch()4612 PartialRunSetupRequest::mutable_fetch() {
4613 // @@protoc_insertion_point(field_mutable_list:tensorflow.PartialRunSetupRequest.fetch)
4614 return &_impl_.fetch_;
4615 }
4616
4617 // repeated string target = 4;
_internal_target_size()4618 inline int PartialRunSetupRequest::_internal_target_size() const {
4619 return _impl_.target_.size();
4620 }
target_size()4621 inline int PartialRunSetupRequest::target_size() const {
4622 return _internal_target_size();
4623 }
clear_target()4624 inline void PartialRunSetupRequest::clear_target() {
4625 _impl_.target_.Clear();
4626 }
add_target()4627 inline std::string* PartialRunSetupRequest::add_target() {
4628 std::string* _s = _internal_add_target();
4629 // @@protoc_insertion_point(field_add_mutable:tensorflow.PartialRunSetupRequest.target)
4630 return _s;
4631 }
_internal_target(int index)4632 inline const std::string& PartialRunSetupRequest::_internal_target(int index) const {
4633 return _impl_.target_.Get(index);
4634 }
target(int index)4635 inline const std::string& PartialRunSetupRequest::target(int index) const {
4636 // @@protoc_insertion_point(field_get:tensorflow.PartialRunSetupRequest.target)
4637 return _internal_target(index);
4638 }
mutable_target(int index)4639 inline std::string* PartialRunSetupRequest::mutable_target(int index) {
4640 // @@protoc_insertion_point(field_mutable:tensorflow.PartialRunSetupRequest.target)
4641 return _impl_.target_.Mutable(index);
4642 }
set_target(int index,const std::string & value)4643 inline void PartialRunSetupRequest::set_target(int index, const std::string& value) {
4644 _impl_.target_.Mutable(index)->assign(value);
4645 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.target)
4646 }
set_target(int index,std::string && value)4647 inline void PartialRunSetupRequest::set_target(int index, std::string&& value) {
4648 _impl_.target_.Mutable(index)->assign(std::move(value));
4649 // @@protoc_insertion_point(field_set:tensorflow.PartialRunSetupRequest.target)
4650 }
set_target(int index,const char * value)4651 inline void PartialRunSetupRequest::set_target(int index, const char* value) {
4652 GOOGLE_DCHECK(value != nullptr);
4653 _impl_.target_.Mutable(index)->assign(value);
4654 // @@protoc_insertion_point(field_set_char:tensorflow.PartialRunSetupRequest.target)
4655 }
set_target(int index,const char * value,size_t size)4656 inline void PartialRunSetupRequest::set_target(int index, const char* value, size_t size) {
4657 _impl_.target_.Mutable(index)->assign(
4658 reinterpret_cast<const char*>(value), size);
4659 // @@protoc_insertion_point(field_set_pointer:tensorflow.PartialRunSetupRequest.target)
4660 }
_internal_add_target()4661 inline std::string* PartialRunSetupRequest::_internal_add_target() {
4662 return _impl_.target_.Add();
4663 }
add_target(const std::string & value)4664 inline void PartialRunSetupRequest::add_target(const std::string& value) {
4665 _impl_.target_.Add()->assign(value);
4666 // @@protoc_insertion_point(field_add:tensorflow.PartialRunSetupRequest.target)
4667 }
add_target(std::string && value)4668 inline void PartialRunSetupRequest::add_target(std::string&& value) {
4669 _impl_.target_.Add(std::move(value));
4670 // @@protoc_insertion_point(field_add:tensorflow.PartialRunSetupRequest.target)
4671 }
add_target(const char * value)4672 inline void PartialRunSetupRequest::add_target(const char* value) {
4673 GOOGLE_DCHECK(value != nullptr);
4674 _impl_.target_.Add()->assign(value);
4675 // @@protoc_insertion_point(field_add_char:tensorflow.PartialRunSetupRequest.target)
4676 }
add_target(const char * value,size_t size)4677 inline void PartialRunSetupRequest::add_target(const char* value, size_t size) {
4678 _impl_.target_.Add()->assign(reinterpret_cast<const char*>(value), size);
4679 // @@protoc_insertion_point(field_add_pointer:tensorflow.PartialRunSetupRequest.target)
4680 }
4681 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
target()4682 PartialRunSetupRequest::target() const {
4683 // @@protoc_insertion_point(field_list:tensorflow.PartialRunSetupRequest.target)
4684 return _impl_.target_;
4685 }
4686 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_target()4687 PartialRunSetupRequest::mutable_target() {
4688 // @@protoc_insertion_point(field_mutable_list:tensorflow.PartialRunSetupRequest.target)
4689 return &_impl_.target_;
4690 }
4691
4692 // int64 request_id = 5;
clear_request_id()4693 inline void PartialRunSetupRequest::clear_request_id() {
4694 _impl_.request_id_ = ::int64_t{0};
4695 }
_internal_request_id()4696 inline ::int64_t PartialRunSetupRequest::_internal_request_id() const {
4697 return _impl_.request_id_;
4698 }
request_id()4699 inline ::int64_t PartialRunSetupRequest::request_id() const {
4700 // @@protoc_insertion_point(field_get:tensorflow.PartialRunSetupRequest.request_id)
4701 return _internal_request_id();
4702 }
_internal_set_request_id(::int64_t value)4703