1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/protobuf/replay_log.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3009000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/unknown_field_set.h>
35#include "tensorflow/core/protobuf/master.pb.h"
36// @@protoc_insertion_point(includes)
37#include <google/protobuf/port_def.inc>
38#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto
39PROTOBUF_NAMESPACE_OPEN
40namespace internal {
41class AnyMetadata;
42} // namespace internal
43PROTOBUF_NAMESPACE_CLOSE
44
45// Internal implementation detail -- do not use these members.
46struct TableStruct_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto {
47 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
48 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
49 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
50 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
52 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
53 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
54 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
55 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
56};
57extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto;
58namespace tensorflow {
59class NewReplaySession;
60class NewReplaySessionDefaultTypeInternal;
61extern NewReplaySessionDefaultTypeInternal _NewReplaySession_default_instance_;
62class ReplayOp;
63class ReplayOpDefaultTypeInternal;
64extern ReplayOpDefaultTypeInternal _ReplayOp_default_instance_;
65} // namespace tensorflow
66PROTOBUF_NAMESPACE_OPEN
67template<> ::tensorflow::NewReplaySession* Arena::CreateMaybeMessage<::tensorflow::NewReplaySession>(Arena*);
68template<> ::tensorflow::ReplayOp* Arena::CreateMaybeMessage<::tensorflow::ReplayOp>(Arena*);
69PROTOBUF_NAMESPACE_CLOSE
70namespace tensorflow {
71
72// ===================================================================
73
74class NewReplaySession :
75 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.NewReplaySession) */ {
76 public:
77 NewReplaySession();
78 virtual ~NewReplaySession();
79
80 NewReplaySession(const NewReplaySession& from);
81 NewReplaySession(NewReplaySession&& from) noexcept
82 : NewReplaySession() {
83 *this = ::std::move(from);
84 }
85
86 inline NewReplaySession& operator=(const NewReplaySession& from) {
87 CopyFrom(from);
88 return *this;
89 }
90 inline NewReplaySession& operator=(NewReplaySession&& from) noexcept {
91 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
92 if (this != &from) InternalSwap(&from);
93 } else {
94 CopyFrom(from);
95 }
96 return *this;
97 }
98
99 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
100 return GetArenaNoVirtual();
101 }
102 inline void* GetMaybeArenaPointer() const final {
103 return MaybeArenaPtr();
104 }
105 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
106 return GetDescriptor();
107 }
108 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
109 return GetMetadataStatic().descriptor;
110 }
111 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
112 return GetMetadataStatic().reflection;
113 }
114 static const NewReplaySession& default_instance();
115
116 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
117 static inline const NewReplaySession* internal_default_instance() {
118 return reinterpret_cast<const NewReplaySession*>(
119 &_NewReplaySession_default_instance_);
120 }
121 static constexpr int kIndexInFileMessages =
122 0;
123
124 friend void swap(NewReplaySession& a, NewReplaySession& b) {
125 a.Swap(&b);
126 }
127 inline void Swap(NewReplaySession* other) {
128 if (other == this) return;
129 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
130 InternalSwap(other);
131 } else {
132 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
133 }
134 }
135 void UnsafeArenaSwap(NewReplaySession* other) {
136 if (other == this) return;
137 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
138 InternalSwap(other);
139 }
140
141 // implements Message ----------------------------------------------
142
143 inline NewReplaySession* New() const final {
144 return CreateMaybeMessage<NewReplaySession>(nullptr);
145 }
146
147 NewReplaySession* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
148 return CreateMaybeMessage<NewReplaySession>(arena);
149 }
150 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
151 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
152 void CopyFrom(const NewReplaySession& from);
153 void MergeFrom(const NewReplaySession& from);
154 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
155 bool IsInitialized() const final;
156
157 size_t ByteSizeLong() const final;
158 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
159 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
160 #else
161 bool MergePartialFromCodedStream(
162 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
163 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
164 void SerializeWithCachedSizes(
165 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
166 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
167 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
168 int GetCachedSize() const final { return _cached_size_.Get(); }
169
170 private:
171 inline void SharedCtor();
172 inline void SharedDtor();
173 void SetCachedSize(int size) const final;
174 void InternalSwap(NewReplaySession* other);
175 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
176 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
177 return "tensorflow.NewReplaySession";
178 }
179 protected:
180 explicit NewReplaySession(::PROTOBUF_NAMESPACE_ID::Arena* arena);
181 private:
182 static void ArenaDtor(void* object);
183 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
184 private:
185 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
186 return _internal_metadata_.arena();
187 }
188 inline void* MaybeArenaPtr() const {
189 return _internal_metadata_.raw_arena_ptr();
190 }
191 public:
192
193 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
194 private:
195 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
196 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto);
197 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
198 }
199
200 public:
201
202 // nested types ----------------------------------------------------
203
204 // accessors -------------------------------------------------------
205
206 enum : int {
207 kSessionHandleFieldNumber = 2,
208 kDevicesFieldNumber = 1,
209 };
210 // string session_handle = 2;
211 void clear_session_handle();
212 const std::string& session_handle() const;
213 void set_session_handle(const std::string& value);
214 void set_session_handle(std::string&& value);
215 void set_session_handle(const char* value);
216 void set_session_handle(const char* value, size_t size);
217 std::string* mutable_session_handle();
218 std::string* release_session_handle();
219 void set_allocated_session_handle(std::string* session_handle);
220 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
221 " string fields are deprecated and will be removed in a"
222 " future release.")
223 std::string* unsafe_arena_release_session_handle();
224 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
225 " string fields are deprecated and will be removed in a"
226 " future release.")
227 void unsafe_arena_set_allocated_session_handle(
228 std::string* session_handle);
229
230 // .tensorflow.ListDevicesResponse devices = 1;
231 bool has_devices() const;
232 void clear_devices();
233 const ::tensorflow::ListDevicesResponse& devices() const;
234 ::tensorflow::ListDevicesResponse* release_devices();
235 ::tensorflow::ListDevicesResponse* mutable_devices();
236 void set_allocated_devices(::tensorflow::ListDevicesResponse* devices);
237 void unsafe_arena_set_allocated_devices(
238 ::tensorflow::ListDevicesResponse* devices);
239 ::tensorflow::ListDevicesResponse* unsafe_arena_release_devices();
240
241 // @@protoc_insertion_point(class_scope:tensorflow.NewReplaySession)
242 private:
243 class _Internal;
244
245 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
246 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
247 typedef void InternalArenaConstructable_;
248 typedef void DestructorSkippable_;
249 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_handle_;
250 ::tensorflow::ListDevicesResponse* devices_;
251 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
252 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto;
253};
254// -------------------------------------------------------------------
255
256class ReplayOp :
257 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.ReplayOp) */ {
258 public:
259 ReplayOp();
260 virtual ~ReplayOp();
261
262 ReplayOp(const ReplayOp& from);
263 ReplayOp(ReplayOp&& from) noexcept
264 : ReplayOp() {
265 *this = ::std::move(from);
266 }
267
268 inline ReplayOp& operator=(const ReplayOp& from) {
269 CopyFrom(from);
270 return *this;
271 }
272 inline ReplayOp& operator=(ReplayOp&& from) noexcept {
273 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
274 if (this != &from) InternalSwap(&from);
275 } else {
276 CopyFrom(from);
277 }
278 return *this;
279 }
280
281 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
282 return GetArenaNoVirtual();
283 }
284 inline void* GetMaybeArenaPointer() const final {
285 return MaybeArenaPtr();
286 }
287 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
288 return GetDescriptor();
289 }
290 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
291 return GetMetadataStatic().descriptor;
292 }
293 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
294 return GetMetadataStatic().reflection;
295 }
296 static const ReplayOp& default_instance();
297
298 enum OpCase {
299 kCreateSession = 1,
300 kExtendSession = 2,
301 kPartialRunSetup = 3,
302 kRunStep = 4,
303 kCloseSession = 5,
304 kListDevices = 6,
305 kResetRequest = 7,
306 kMakeCallable = 8,
307 kRunCallable = 9,
308 kReleaseCallable = 10,
309 kNewReplaySession = 11,
310 OP_NOT_SET = 0,
311 };
312
313 enum ResponseCase {
314 kCreateSessionResponse = 21,
315 kExtendSessionResponse = 22,
316 kPartialRunSetupResponse = 23,
317 kRunStepResponse = 24,
318 kCloseSessionResponse = 25,
319 kListDevicesResponse = 26,
320 kResetRequestResponse = 27,
321 kMakeCallableResponse = 28,
322 kRunCallableResponse = 29,
323 kReleaseCallableResponse = 30,
324 RESPONSE_NOT_SET = 0,
325 };
326
327 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
328 static inline const ReplayOp* internal_default_instance() {
329 return reinterpret_cast<const ReplayOp*>(
330 &_ReplayOp_default_instance_);
331 }
332 static constexpr int kIndexInFileMessages =
333 1;
334
335 friend void swap(ReplayOp& a, ReplayOp& b) {
336 a.Swap(&b);
337 }
338 inline void Swap(ReplayOp* other) {
339 if (other == this) return;
340 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
341 InternalSwap(other);
342 } else {
343 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
344 }
345 }
346 void UnsafeArenaSwap(ReplayOp* other) {
347 if (other == this) return;
348 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
349 InternalSwap(other);
350 }
351
352 // implements Message ----------------------------------------------
353
354 inline ReplayOp* New() const final {
355 return CreateMaybeMessage<ReplayOp>(nullptr);
356 }
357
358 ReplayOp* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
359 return CreateMaybeMessage<ReplayOp>(arena);
360 }
361 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
362 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
363 void CopyFrom(const ReplayOp& from);
364 void MergeFrom(const ReplayOp& from);
365 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
366 bool IsInitialized() const final;
367
368 size_t ByteSizeLong() const final;
369 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
370 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
371 #else
372 bool MergePartialFromCodedStream(
373 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
374 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
375 void SerializeWithCachedSizes(
376 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
377 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
378 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
379 int GetCachedSize() const final { return _cached_size_.Get(); }
380
381 private:
382 inline void SharedCtor();
383 inline void SharedDtor();
384 void SetCachedSize(int size) const final;
385 void InternalSwap(ReplayOp* other);
386 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
387 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
388 return "tensorflow.ReplayOp";
389 }
390 protected:
391 explicit ReplayOp(::PROTOBUF_NAMESPACE_ID::Arena* arena);
392 private:
393 static void ArenaDtor(void* object);
394 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
395 private:
396 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
397 return _internal_metadata_.arena();
398 }
399 inline void* MaybeArenaPtr() const {
400 return _internal_metadata_.raw_arena_ptr();
401 }
402 public:
403
404 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
405 private:
406 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
407 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto);
408 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto.file_level_metadata[kIndexInFileMessages];
409 }
410
411 public:
412
413 // nested types ----------------------------------------------------
414
415 // accessors -------------------------------------------------------
416
417 enum : int {
418 kStartTimeUsFieldNumber = 31,
419 kEndTimeUsFieldNumber = 32,
420 kCreateSessionFieldNumber = 1,
421 kExtendSessionFieldNumber = 2,
422 kPartialRunSetupFieldNumber = 3,
423 kRunStepFieldNumber = 4,
424 kCloseSessionFieldNumber = 5,
425 kListDevicesFieldNumber = 6,
426 kResetRequestFieldNumber = 7,
427 kMakeCallableFieldNumber = 8,
428 kRunCallableFieldNumber = 9,
429 kReleaseCallableFieldNumber = 10,
430 kNewReplaySessionFieldNumber = 11,
431 kCreateSessionResponseFieldNumber = 21,
432 kExtendSessionResponseFieldNumber = 22,
433 kPartialRunSetupResponseFieldNumber = 23,
434 kRunStepResponseFieldNumber = 24,
435 kCloseSessionResponseFieldNumber = 25,
436 kListDevicesResponseFieldNumber = 26,
437 kResetRequestResponseFieldNumber = 27,
438 kMakeCallableResponseFieldNumber = 28,
439 kRunCallableResponseFieldNumber = 29,
440 kReleaseCallableResponseFieldNumber = 30,
441 };
442 // double start_time_us = 31;
443 void clear_start_time_us();
444 double start_time_us() const;
445 void set_start_time_us(double value);
446
447 // double end_time_us = 32;
448 void clear_end_time_us();
449 double end_time_us() const;
450 void set_end_time_us(double value);
451
452 // .tensorflow.CreateSessionRequest create_session = 1;
453 bool has_create_session() const;
454 void clear_create_session();
455 const ::tensorflow::CreateSessionRequest& create_session() const;
456 ::tensorflow::CreateSessionRequest* release_create_session();
457 ::tensorflow::CreateSessionRequest* mutable_create_session();
458 void set_allocated_create_session(::tensorflow::CreateSessionRequest* create_session);
459 void unsafe_arena_set_allocated_create_session(
460 ::tensorflow::CreateSessionRequest* create_session);
461 ::tensorflow::CreateSessionRequest* unsafe_arena_release_create_session();
462
463 // .tensorflow.ExtendSessionRequest extend_session = 2;
464 bool has_extend_session() const;
465 void clear_extend_session();
466 const ::tensorflow::ExtendSessionRequest& extend_session() const;
467 ::tensorflow::ExtendSessionRequest* release_extend_session();
468 ::tensorflow::ExtendSessionRequest* mutable_extend_session();
469 void set_allocated_extend_session(::tensorflow::ExtendSessionRequest* extend_session);
470 void unsafe_arena_set_allocated_extend_session(
471 ::tensorflow::ExtendSessionRequest* extend_session);
472 ::tensorflow::ExtendSessionRequest* unsafe_arena_release_extend_session();
473
474 // .tensorflow.PartialRunSetupRequest partial_run_setup = 3;
475 bool has_partial_run_setup() const;
476 void clear_partial_run_setup();
477 const ::tensorflow::PartialRunSetupRequest& partial_run_setup() const;
478 ::tensorflow::PartialRunSetupRequest* release_partial_run_setup();
479 ::tensorflow::PartialRunSetupRequest* mutable_partial_run_setup();
480 void set_allocated_partial_run_setup(::tensorflow::PartialRunSetupRequest* partial_run_setup);
481 void unsafe_arena_set_allocated_partial_run_setup(
482 ::tensorflow::PartialRunSetupRequest* partial_run_setup);
483 ::tensorflow::PartialRunSetupRequest* unsafe_arena_release_partial_run_setup();
484
485 // .tensorflow.RunStepRequest run_step = 4;
486 bool has_run_step() const;
487 void clear_run_step();
488 const ::tensorflow::RunStepRequest& run_step() const;
489 ::tensorflow::RunStepRequest* release_run_step();
490 ::tensorflow::RunStepRequest* mutable_run_step();
491 void set_allocated_run_step(::tensorflow::RunStepRequest* run_step);
492 void unsafe_arena_set_allocated_run_step(
493 ::tensorflow::RunStepRequest* run_step);
494 ::tensorflow::RunStepRequest* unsafe_arena_release_run_step();
495
496 // .tensorflow.CloseSessionRequest close_session = 5;
497 bool has_close_session() const;
498 void clear_close_session();
499 const ::tensorflow::CloseSessionRequest& close_session() const;
500 ::tensorflow::CloseSessionRequest* release_close_session();
501 ::tensorflow::CloseSessionRequest* mutable_close_session();
502 void set_allocated_close_session(::tensorflow::CloseSessionRequest* close_session);
503 void unsafe_arena_set_allocated_close_session(
504 ::tensorflow::CloseSessionRequest* close_session);
505 ::tensorflow::CloseSessionRequest* unsafe_arena_release_close_session();
506
507 // .tensorflow.ListDevicesRequest list_devices = 6;
508 bool has_list_devices() const;
509 void clear_list_devices();
510 const ::tensorflow::ListDevicesRequest& list_devices() const;
511 ::tensorflow::ListDevicesRequest* release_list_devices();
512 ::tensorflow::ListDevicesRequest* mutable_list_devices();
513 void set_allocated_list_devices(::tensorflow::ListDevicesRequest* list_devices);
514 void unsafe_arena_set_allocated_list_devices(
515 ::tensorflow::ListDevicesRequest* list_devices);
516 ::tensorflow::ListDevicesRequest* unsafe_arena_release_list_devices();
517
518 // .tensorflow.ResetRequest reset_request = 7;
519 bool has_reset_request() const;
520 void clear_reset_request();
521 const ::tensorflow::ResetRequest& reset_request() const;
522 ::tensorflow::ResetRequest* release_reset_request();
523 ::tensorflow::ResetRequest* mutable_reset_request();
524 void set_allocated_reset_request(::tensorflow::ResetRequest* reset_request);
525 void unsafe_arena_set_allocated_reset_request(
526 ::tensorflow::ResetRequest* reset_request);
527 ::tensorflow::ResetRequest* unsafe_arena_release_reset_request();
528
529 // .tensorflow.MakeCallableRequest make_callable = 8;
530 bool has_make_callable() const;
531 void clear_make_callable();
532 const ::tensorflow::MakeCallableRequest& make_callable() const;
533 ::tensorflow::MakeCallableRequest* release_make_callable();
534 ::tensorflow::MakeCallableRequest* mutable_make_callable();
535 void set_allocated_make_callable(::tensorflow::MakeCallableRequest* make_callable);
536 void unsafe_arena_set_allocated_make_callable(
537 ::tensorflow::MakeCallableRequest* make_callable);
538 ::tensorflow::MakeCallableRequest* unsafe_arena_release_make_callable();
539
540 // .tensorflow.RunCallableRequest run_callable = 9;
541 bool has_run_callable() const;
542 void clear_run_callable();
543 const ::tensorflow::RunCallableRequest& run_callable() const;
544 ::tensorflow::RunCallableRequest* release_run_callable();
545 ::tensorflow::RunCallableRequest* mutable_run_callable();
546 void set_allocated_run_callable(::tensorflow::RunCallableRequest* run_callable);
547 void unsafe_arena_set_allocated_run_callable(
548 ::tensorflow::RunCallableRequest* run_callable);
549 ::tensorflow::RunCallableRequest* unsafe_arena_release_run_callable();
550
551 // .tensorflow.ReleaseCallableRequest release_callable = 10;
552 bool has_release_callable() const;
553 void clear_release_callable();
554 const ::tensorflow::ReleaseCallableRequest& release_callable() const;
555 ::tensorflow::ReleaseCallableRequest* release_release_callable();
556 ::tensorflow::ReleaseCallableRequest* mutable_release_callable();
557 void set_allocated_release_callable(::tensorflow::ReleaseCallableRequest* release_callable);
558 void unsafe_arena_set_allocated_release_callable(
559 ::tensorflow::ReleaseCallableRequest* release_callable);
560 ::tensorflow::ReleaseCallableRequest* unsafe_arena_release_release_callable();
561
562 // .tensorflow.NewReplaySession new_replay_session = 11;
563 bool has_new_replay_session() const;
564 void clear_new_replay_session();
565 const ::tensorflow::NewReplaySession& new_replay_session() const;
566 ::tensorflow::NewReplaySession* release_new_replay_session();
567 ::tensorflow::NewReplaySession* mutable_new_replay_session();
568 void set_allocated_new_replay_session(::tensorflow::NewReplaySession* new_replay_session);
569 void unsafe_arena_set_allocated_new_replay_session(
570 ::tensorflow::NewReplaySession* new_replay_session);
571 ::tensorflow::NewReplaySession* unsafe_arena_release_new_replay_session();
572
573 // .tensorflow.CreateSessionResponse create_session_response = 21;
574 bool has_create_session_response() const;
575 void clear_create_session_response();
576 const ::tensorflow::CreateSessionResponse& create_session_response() const;
577 ::tensorflow::CreateSessionResponse* release_create_session_response();
578 ::tensorflow::CreateSessionResponse* mutable_create_session_response();
579 void set_allocated_create_session_response(::tensorflow::CreateSessionResponse* create_session_response);
580 void unsafe_arena_set_allocated_create_session_response(
581 ::tensorflow::CreateSessionResponse* create_session_response);
582 ::tensorflow::CreateSessionResponse* unsafe_arena_release_create_session_response();
583
584 // .tensorflow.ExtendSessionResponse extend_session_response = 22;
585 bool has_extend_session_response() const;
586 void clear_extend_session_response();
587 const ::tensorflow::ExtendSessionResponse& extend_session_response() const;
588 ::tensorflow::ExtendSessionResponse* release_extend_session_response();
589 ::tensorflow::ExtendSessionResponse* mutable_extend_session_response();
590 void set_allocated_extend_session_response(::tensorflow::ExtendSessionResponse* extend_session_response);
591 void unsafe_arena_set_allocated_extend_session_response(
592 ::tensorflow::ExtendSessionResponse* extend_session_response);
593 ::tensorflow::ExtendSessionResponse* unsafe_arena_release_extend_session_response();
594
595 // .tensorflow.PartialRunSetupResponse partial_run_setup_response = 23;
596 bool has_partial_run_setup_response() const;
597 void clear_partial_run_setup_response();
598 const ::tensorflow::PartialRunSetupResponse& partial_run_setup_response() const;
599 ::tensorflow::PartialRunSetupResponse* release_partial_run_setup_response();
600 ::tensorflow::PartialRunSetupResponse* mutable_partial_run_setup_response();
601 void set_allocated_partial_run_setup_response(::tensorflow::PartialRunSetupResponse* partial_run_setup_response);
602 void unsafe_arena_set_allocated_partial_run_setup_response(
603 ::tensorflow::PartialRunSetupResponse* partial_run_setup_response);
604 ::tensorflow::PartialRunSetupResponse* unsafe_arena_release_partial_run_setup_response();
605
606 // .tensorflow.RunStepResponse run_step_response = 24;
607 bool has_run_step_response() const;
608 void clear_run_step_response();
609 const ::tensorflow::RunStepResponse& run_step_response() const;
610 ::tensorflow::RunStepResponse* release_run_step_response();
611 ::tensorflow::RunStepResponse* mutable_run_step_response();
612 void set_allocated_run_step_response(::tensorflow::RunStepResponse* run_step_response);
613 void unsafe_arena_set_allocated_run_step_response(
614 ::tensorflow::RunStepResponse* run_step_response);
615 ::tensorflow::RunStepResponse* unsafe_arena_release_run_step_response();
616
617 // .tensorflow.CloseSessionResponse close_session_response = 25;
618 bool has_close_session_response() const;
619 void clear_close_session_response();
620 const ::tensorflow::CloseSessionResponse& close_session_response() const;
621 ::tensorflow::CloseSessionResponse* release_close_session_response();
622 ::tensorflow::CloseSessionResponse* mutable_close_session_response();
623 void set_allocated_close_session_response(::tensorflow::CloseSessionResponse* close_session_response);
624 void unsafe_arena_set_allocated_close_session_response(
625 ::tensorflow::CloseSessionResponse* close_session_response);
626 ::tensorflow::CloseSessionResponse* unsafe_arena_release_close_session_response();
627
628 // .tensorflow.ListDevicesResponse list_devices_response = 26;
629 bool has_list_devices_response() const;
630 void clear_list_devices_response();
631 const ::tensorflow::ListDevicesResponse& list_devices_response() const;
632 ::tensorflow::ListDevicesResponse* release_list_devices_response();
633 ::tensorflow::ListDevicesResponse* mutable_list_devices_response();
634 void set_allocated_list_devices_response(::tensorflow::ListDevicesResponse* list_devices_response);
635 void unsafe_arena_set_allocated_list_devices_response(
636 ::tensorflow::ListDevicesResponse* list_devices_response);
637 ::tensorflow::ListDevicesResponse* unsafe_arena_release_list_devices_response();
638
639 // .tensorflow.ResetResponse reset_request_response = 27;
640 bool has_reset_request_response() const;
641 void clear_reset_request_response();
642 const ::tensorflow::ResetResponse& reset_request_response() const;
643 ::tensorflow::ResetResponse* release_reset_request_response();
644 ::tensorflow::ResetResponse* mutable_reset_request_response();
645 void set_allocated_reset_request_response(::tensorflow::ResetResponse* reset_request_response);
646 void unsafe_arena_set_allocated_reset_request_response(
647 ::tensorflow::ResetResponse* reset_request_response);
648 ::tensorflow::ResetResponse* unsafe_arena_release_reset_request_response();
649
650 // .tensorflow.MakeCallableResponse make_callable_response = 28;
651 bool has_make_callable_response() const;
652 void clear_make_callable_response();
653 const ::tensorflow::MakeCallableResponse& make_callable_response() const;
654 ::tensorflow::MakeCallableResponse* release_make_callable_response();
655 ::tensorflow::MakeCallableResponse* mutable_make_callable_response();
656 void set_allocated_make_callable_response(::tensorflow::MakeCallableResponse* make_callable_response);
657 void unsafe_arena_set_allocated_make_callable_response(
658 ::tensorflow::MakeCallableResponse* make_callable_response);
659 ::tensorflow::MakeCallableResponse* unsafe_arena_release_make_callable_response();
660
661 // .tensorflow.RunCallableResponse run_callable_response = 29;
662 bool has_run_callable_response() const;
663 void clear_run_callable_response();
664 const ::tensorflow::RunCallableResponse& run_callable_response() const;
665 ::tensorflow::RunCallableResponse* release_run_callable_response();
666 ::tensorflow::RunCallableResponse* mutable_run_callable_response();
667 void set_allocated_run_callable_response(::tensorflow::RunCallableResponse* run_callable_response);
668 void unsafe_arena_set_allocated_run_callable_response(
669 ::tensorflow::RunCallableResponse* run_callable_response);
670 ::tensorflow::RunCallableResponse* unsafe_arena_release_run_callable_response();
671
672 // .tensorflow.ReleaseCallableResponse release_callable_response = 30;
673 bool has_release_callable_response() const;
674 void clear_release_callable_response();
675 const ::tensorflow::ReleaseCallableResponse& release_callable_response() const;
676 ::tensorflow::ReleaseCallableResponse* release_release_callable_response();
677 ::tensorflow::ReleaseCallableResponse* mutable_release_callable_response();
678 void set_allocated_release_callable_response(::tensorflow::ReleaseCallableResponse* release_callable_response);
679 void unsafe_arena_set_allocated_release_callable_response(
680 ::tensorflow::ReleaseCallableResponse* release_callable_response);
681 ::tensorflow::ReleaseCallableResponse* unsafe_arena_release_release_callable_response();
682
683 void clear_op();
684 OpCase op_case() const;
685 void clear_response();
686 ResponseCase response_case() const;
687 // @@protoc_insertion_point(class_scope:tensorflow.ReplayOp)
688 private:
689 class _Internal;
690 void set_has_create_session();
691 void set_has_extend_session();
692 void set_has_partial_run_setup();
693 void set_has_run_step();
694 void set_has_close_session();
695 void set_has_list_devices();
696 void set_has_reset_request();
697 void set_has_make_callable();
698 void set_has_run_callable();
699 void set_has_release_callable();
700 void set_has_new_replay_session();
701 void set_has_create_session_response();
702 void set_has_extend_session_response();
703 void set_has_partial_run_setup_response();
704 void set_has_run_step_response();
705 void set_has_close_session_response();
706 void set_has_list_devices_response();
707 void set_has_reset_request_response();
708 void set_has_make_callable_response();
709 void set_has_run_callable_response();
710 void set_has_release_callable_response();
711
712 inline bool has_op() const;
713 inline void clear_has_op();
714
715 inline bool has_response() const;
716 inline void clear_has_response();
717
718 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
719 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
720 typedef void InternalArenaConstructable_;
721 typedef void DestructorSkippable_;
722 double start_time_us_;
723 double end_time_us_;
724 union OpUnion {
725 OpUnion() {}
726 ::tensorflow::CreateSessionRequest* create_session_;
727 ::tensorflow::ExtendSessionRequest* extend_session_;
728 ::tensorflow::PartialRunSetupRequest* partial_run_setup_;
729 ::tensorflow::RunStepRequest* run_step_;
730 ::tensorflow::CloseSessionRequest* close_session_;
731 ::tensorflow::ListDevicesRequest* list_devices_;
732 ::tensorflow::ResetRequest* reset_request_;
733 ::tensorflow::MakeCallableRequest* make_callable_;
734 ::tensorflow::RunCallableRequest* run_callable_;
735 ::tensorflow::ReleaseCallableRequest* release_callable_;
736 ::tensorflow::NewReplaySession* new_replay_session_;
737 } op_;
738 union ResponseUnion {
739 ResponseUnion() {}
740 ::tensorflow::CreateSessionResponse* create_session_response_;
741 ::tensorflow::ExtendSessionResponse* extend_session_response_;
742 ::tensorflow::PartialRunSetupResponse* partial_run_setup_response_;
743 ::tensorflow::RunStepResponse* run_step_response_;
744 ::tensorflow::CloseSessionResponse* close_session_response_;
745 ::tensorflow::ListDevicesResponse* list_devices_response_;
746 ::tensorflow::ResetResponse* reset_request_response_;
747 ::tensorflow::MakeCallableResponse* make_callable_response_;
748 ::tensorflow::RunCallableResponse* run_callable_response_;
749 ::tensorflow::ReleaseCallableResponse* release_callable_response_;
750 } response_;
751 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
752 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];
753
754 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto;
755};
756// ===================================================================
757
758
759// ===================================================================
760
761#ifdef __GNUC__
762 #pragma GCC diagnostic push
763 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
764#endif // __GNUC__
765// NewReplaySession
766
767// .tensorflow.ListDevicesResponse devices = 1;
768inline bool NewReplaySession::has_devices() const {
769 return this != internal_default_instance() && devices_ != nullptr;
770}
771inline const ::tensorflow::ListDevicesResponse& NewReplaySession::devices() const {
772 const ::tensorflow::ListDevicesResponse* p = devices_;
773 // @@protoc_insertion_point(field_get:tensorflow.NewReplaySession.devices)
774 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::ListDevicesResponse*>(
775 &::tensorflow::_ListDevicesResponse_default_instance_);
776}
777inline ::tensorflow::ListDevicesResponse* NewReplaySession::release_devices() {
778 // @@protoc_insertion_point(field_release:tensorflow.NewReplaySession.devices)
779
780 ::tensorflow::ListDevicesResponse* temp = devices_;
781 if (GetArenaNoVirtual() != nullptr) {
782 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
783 }
784 devices_ = nullptr;
785 return temp;
786}
787inline ::tensorflow::ListDevicesResponse* NewReplaySession::unsafe_arena_release_devices() {
788 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NewReplaySession.devices)
789
790 ::tensorflow::ListDevicesResponse* temp = devices_;
791 devices_ = nullptr;
792 return temp;
793}
794inline ::tensorflow::ListDevicesResponse* NewReplaySession::mutable_devices() {
795
796 if (devices_ == nullptr) {
797 auto* p = CreateMaybeMessage<::tensorflow::ListDevicesResponse>(GetArenaNoVirtual());
798 devices_ = p;
799 }
800 // @@protoc_insertion_point(field_mutable:tensorflow.NewReplaySession.devices)
801 return devices_;
802}
803inline void NewReplaySession::set_allocated_devices(::tensorflow::ListDevicesResponse* devices) {
804 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
805 if (message_arena == nullptr) {
806 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(devices_);
807 }
808 if (devices) {
809 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
810 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(devices)->GetArena();
811 if (message_arena != submessage_arena) {
812 devices = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
813 message_arena, devices, submessage_arena);
814 }
815
816 } else {
817
818 }
819 devices_ = devices;
820 // @@protoc_insertion_point(field_set_allocated:tensorflow.NewReplaySession.devices)
821}
822
823// string session_handle = 2;
824inline void NewReplaySession::clear_session_handle() {
825 session_handle_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
826}
827inline const std::string& NewReplaySession::session_handle() const {
828 // @@protoc_insertion_point(field_get:tensorflow.NewReplaySession.session_handle)
829 return session_handle_.Get();
830}
831inline void NewReplaySession::set_session_handle(const std::string& value) {
832
833 session_handle_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
834 // @@protoc_insertion_point(field_set:tensorflow.NewReplaySession.session_handle)
835}
836inline void NewReplaySession::set_session_handle(std::string&& value) {
837
838 session_handle_.Set(
839 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
840 // @@protoc_insertion_point(field_set_rvalue:tensorflow.NewReplaySession.session_handle)
841}
842inline void NewReplaySession::set_session_handle(const char* value) {
843 GOOGLE_DCHECK(value != nullptr);
844
845 session_handle_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
846 GetArenaNoVirtual());
847 // @@protoc_insertion_point(field_set_char:tensorflow.NewReplaySession.session_handle)
848}
849inline void NewReplaySession::set_session_handle(const char* value,
850 size_t size) {
851
852 session_handle_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
853 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
854 // @@protoc_insertion_point(field_set_pointer:tensorflow.NewReplaySession.session_handle)
855}
856inline std::string* NewReplaySession::mutable_session_handle() {
857
858 // @@protoc_insertion_point(field_mutable:tensorflow.NewReplaySession.session_handle)
859 return session_handle_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
860}
861inline std::string* NewReplaySession::release_session_handle() {
862 // @@protoc_insertion_point(field_release:tensorflow.NewReplaySession.session_handle)
863
864 return session_handle_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
865}
866inline void NewReplaySession::set_allocated_session_handle(std::string* session_handle) {
867 if (session_handle != nullptr) {
868
869 } else {
870
871 }
872 session_handle_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_handle,
873 GetArenaNoVirtual());
874 // @@protoc_insertion_point(field_set_allocated:tensorflow.NewReplaySession.session_handle)
875}
876inline std::string* NewReplaySession::unsafe_arena_release_session_handle() {
877 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.NewReplaySession.session_handle)
878 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
879
880 return session_handle_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
881 GetArenaNoVirtual());
882}
883inline void NewReplaySession::unsafe_arena_set_allocated_session_handle(
884 std::string* session_handle) {
885 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
886 if (session_handle != nullptr) {
887
888 } else {
889
890 }
891 session_handle_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
892 session_handle, GetArenaNoVirtual());
893 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.NewReplaySession.session_handle)
894}
895
896// -------------------------------------------------------------------
897
898// ReplayOp
899
900// double start_time_us = 31;
901inline void ReplayOp::clear_start_time_us() {
902 start_time_us_ = 0;
903}
904inline double ReplayOp::start_time_us() const {
905 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.start_time_us)
906 return start_time_us_;
907}
908inline void ReplayOp::set_start_time_us(double value) {
909
910 start_time_us_ = value;
911 // @@protoc_insertion_point(field_set:tensorflow.ReplayOp.start_time_us)
912}
913
914// double end_time_us = 32;
915inline void ReplayOp::clear_end_time_us() {
916 end_time_us_ = 0;
917}
918inline double ReplayOp::end_time_us() const {
919 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.end_time_us)
920 return end_time_us_;
921}
922inline void ReplayOp::set_end_time_us(double value) {
923
924 end_time_us_ = value;
925 // @@protoc_insertion_point(field_set:tensorflow.ReplayOp.end_time_us)
926}
927
928// .tensorflow.CreateSessionRequest create_session = 1;
929inline bool ReplayOp::has_create_session() const {
930 return op_case() == kCreateSession;
931}
932inline void ReplayOp::set_has_create_session() {
933 _oneof_case_[0] = kCreateSession;
934}
935inline ::tensorflow::CreateSessionRequest* ReplayOp::release_create_session() {
936 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.create_session)
937 if (has_create_session()) {
938 clear_has_op();
939 ::tensorflow::CreateSessionRequest* temp = op_.create_session_;
940 if (GetArenaNoVirtual() != nullptr) {
941 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
942 }
943 op_.create_session_ = nullptr;
944 return temp;
945 } else {
946 return nullptr;
947 }
948}
949inline const ::tensorflow::CreateSessionRequest& ReplayOp::create_session() const {
950 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.create_session)
951 return has_create_session()
952 ? *op_.create_session_
953 : *reinterpret_cast< ::tensorflow::CreateSessionRequest*>(&::tensorflow::_CreateSessionRequest_default_instance_);
954}
955inline ::tensorflow::CreateSessionRequest* ReplayOp::unsafe_arena_release_create_session() {
956 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.create_session)
957 if (has_create_session()) {
958 clear_has_op();
959 ::tensorflow::CreateSessionRequest* temp = op_.create_session_;
960 op_.create_session_ = nullptr;
961 return temp;
962 } else {
963 return nullptr;
964 }
965}
966inline void ReplayOp::unsafe_arena_set_allocated_create_session(::tensorflow::CreateSessionRequest* create_session) {
967 clear_op();
968 if (create_session) {
969 set_has_create_session();
970 op_.create_session_ = create_session;
971 }
972 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.create_session)
973}
974inline ::tensorflow::CreateSessionRequest* ReplayOp::mutable_create_session() {
975 if (!has_create_session()) {
976 clear_op();
977 set_has_create_session();
978 op_.create_session_ = CreateMaybeMessage< ::tensorflow::CreateSessionRequest >(
979 GetArenaNoVirtual());
980 }
981 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.create_session)
982 return op_.create_session_;
983}
984
985// .tensorflow.ExtendSessionRequest extend_session = 2;
986inline bool ReplayOp::has_extend_session() const {
987 return op_case() == kExtendSession;
988}
989inline void ReplayOp::set_has_extend_session() {
990 _oneof_case_[0] = kExtendSession;
991}
992inline ::tensorflow::ExtendSessionRequest* ReplayOp::release_extend_session() {
993 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.extend_session)
994 if (has_extend_session()) {
995 clear_has_op();
996 ::tensorflow::ExtendSessionRequest* temp = op_.extend_session_;
997 if (GetArenaNoVirtual() != nullptr) {
998 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
999 }
1000 op_.extend_session_ = nullptr;
1001 return temp;
1002 } else {
1003 return nullptr;
1004 }
1005}
1006inline const ::tensorflow::ExtendSessionRequest& ReplayOp::extend_session() const {
1007 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.extend_session)
1008 return has_extend_session()
1009 ? *op_.extend_session_
1010 : *reinterpret_cast< ::tensorflow::ExtendSessionRequest*>(&::tensorflow::_ExtendSessionRequest_default_instance_);
1011}
1012inline ::tensorflow::ExtendSessionRequest* ReplayOp::unsafe_arena_release_extend_session() {
1013 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.extend_session)
1014 if (has_extend_session()) {
1015 clear_has_op();
1016 ::tensorflow::ExtendSessionRequest* temp = op_.extend_session_;
1017 op_.extend_session_ = nullptr;
1018 return temp;
1019 } else {
1020 return nullptr;
1021 }
1022}
1023inline void ReplayOp::unsafe_arena_set_allocated_extend_session(::tensorflow::ExtendSessionRequest* extend_session) {
1024 clear_op();
1025 if (extend_session) {
1026 set_has_extend_session();
1027 op_.extend_session_ = extend_session;
1028 }
1029 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.extend_session)
1030}
1031inline ::tensorflow::ExtendSessionRequest* ReplayOp::mutable_extend_session() {
1032 if (!has_extend_session()) {
1033 clear_op();
1034 set_has_extend_session();
1035 op_.extend_session_ = CreateMaybeMessage< ::tensorflow::ExtendSessionRequest >(
1036 GetArenaNoVirtual());
1037 }
1038 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.extend_session)
1039 return op_.extend_session_;
1040}
1041
1042// .tensorflow.PartialRunSetupRequest partial_run_setup = 3;
1043inline bool ReplayOp::has_partial_run_setup() const {
1044 return op_case() == kPartialRunSetup;
1045}
1046inline void ReplayOp::set_has_partial_run_setup() {
1047 _oneof_case_[0] = kPartialRunSetup;
1048}
1049inline ::tensorflow::PartialRunSetupRequest* ReplayOp::release_partial_run_setup() {
1050 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.partial_run_setup)
1051 if (has_partial_run_setup()) {
1052 clear_has_op();
1053 ::tensorflow::PartialRunSetupRequest* temp = op_.partial_run_setup_;
1054 if (GetArenaNoVirtual() != nullptr) {
1055 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1056 }
1057 op_.partial_run_setup_ = nullptr;
1058 return temp;
1059 } else {
1060 return nullptr;
1061 }
1062}
1063inline const ::tensorflow::PartialRunSetupRequest& ReplayOp::partial_run_setup() const {
1064 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.partial_run_setup)
1065 return has_partial_run_setup()
1066 ? *op_.partial_run_setup_
1067 : *reinterpret_cast< ::tensorflow::PartialRunSetupRequest*>(&::tensorflow::_PartialRunSetupRequest_default_instance_);
1068}
1069inline ::tensorflow::PartialRunSetupRequest* ReplayOp::unsafe_arena_release_partial_run_setup() {
1070 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.partial_run_setup)
1071 if (has_partial_run_setup()) {
1072 clear_has_op();
1073 ::tensorflow::PartialRunSetupRequest* temp = op_.partial_run_setup_;
1074 op_.partial_run_setup_ = nullptr;
1075 return temp;
1076 } else {
1077 return nullptr;
1078 }
1079}
1080inline void ReplayOp::unsafe_arena_set_allocated_partial_run_setup(::tensorflow::PartialRunSetupRequest* partial_run_setup) {
1081 clear_op();
1082 if (partial_run_setup) {
1083 set_has_partial_run_setup();
1084 op_.partial_run_setup_ = partial_run_setup;
1085 }
1086 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.partial_run_setup)
1087}
1088inline ::tensorflow::PartialRunSetupRequest* ReplayOp::mutable_partial_run_setup() {
1089 if (!has_partial_run_setup()) {
1090 clear_op();
1091 set_has_partial_run_setup();
1092 op_.partial_run_setup_ = CreateMaybeMessage< ::tensorflow::PartialRunSetupRequest >(
1093 GetArenaNoVirtual());
1094 }
1095 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.partial_run_setup)
1096 return op_.partial_run_setup_;
1097}
1098
1099// .tensorflow.RunStepRequest run_step = 4;
1100inline bool ReplayOp::has_run_step() const {
1101 return op_case() == kRunStep;
1102}
1103inline void ReplayOp::set_has_run_step() {
1104 _oneof_case_[0] = kRunStep;
1105}
1106inline ::tensorflow::RunStepRequest* ReplayOp::release_run_step() {
1107 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.run_step)
1108 if (has_run_step()) {
1109 clear_has_op();
1110 ::tensorflow::RunStepRequest* temp = op_.run_step_;
1111 if (GetArenaNoVirtual() != nullptr) {
1112 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1113 }
1114 op_.run_step_ = nullptr;
1115 return temp;
1116 } else {
1117 return nullptr;
1118 }
1119}
1120inline const ::tensorflow::RunStepRequest& ReplayOp::run_step() const {
1121 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.run_step)
1122 return has_run_step()
1123 ? *op_.run_step_
1124 : *reinterpret_cast< ::tensorflow::RunStepRequest*>(&::tensorflow::_RunStepRequest_default_instance_);
1125}
1126inline ::tensorflow::RunStepRequest* ReplayOp::unsafe_arena_release_run_step() {
1127 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.run_step)
1128 if (has_run_step()) {
1129 clear_has_op();
1130 ::tensorflow::RunStepRequest* temp = op_.run_step_;
1131 op_.run_step_ = nullptr;
1132 return temp;
1133 } else {
1134 return nullptr;
1135 }
1136}
1137inline void ReplayOp::unsafe_arena_set_allocated_run_step(::tensorflow::RunStepRequest* run_step) {
1138 clear_op();
1139 if (run_step) {
1140 set_has_run_step();
1141 op_.run_step_ = run_step;
1142 }
1143 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.run_step)
1144}
1145inline ::tensorflow::RunStepRequest* ReplayOp::mutable_run_step() {
1146 if (!has_run_step()) {
1147 clear_op();
1148 set_has_run_step();
1149 op_.run_step_ = CreateMaybeMessage< ::tensorflow::RunStepRequest >(
1150 GetArenaNoVirtual());
1151 }
1152 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.run_step)
1153 return op_.run_step_;
1154}
1155
1156// .tensorflow.CloseSessionRequest close_session = 5;
1157inline bool ReplayOp::has_close_session() const {
1158 return op_case() == kCloseSession;
1159}
1160inline void ReplayOp::set_has_close_session() {
1161 _oneof_case_[0] = kCloseSession;
1162}
1163inline ::tensorflow::CloseSessionRequest* ReplayOp::release_close_session() {
1164 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.close_session)
1165 if (has_close_session()) {
1166 clear_has_op();
1167 ::tensorflow::CloseSessionRequest* temp = op_.close_session_;
1168 if (GetArenaNoVirtual() != nullptr) {
1169 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1170 }
1171 op_.close_session_ = nullptr;
1172 return temp;
1173 } else {
1174 return nullptr;
1175 }
1176}
1177inline const ::tensorflow::CloseSessionRequest& ReplayOp::close_session() const {
1178 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.close_session)
1179 return has_close_session()
1180 ? *op_.close_session_
1181 : *reinterpret_cast< ::tensorflow::CloseSessionRequest*>(&::tensorflow::_CloseSessionRequest_default_instance_);
1182}
1183inline ::tensorflow::CloseSessionRequest* ReplayOp::unsafe_arena_release_close_session() {
1184 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.close_session)
1185 if (has_close_session()) {
1186 clear_has_op();
1187 ::tensorflow::CloseSessionRequest* temp = op_.close_session_;
1188 op_.close_session_ = nullptr;
1189 return temp;
1190 } else {
1191 return nullptr;
1192 }
1193}
1194inline void ReplayOp::unsafe_arena_set_allocated_close_session(::tensorflow::CloseSessionRequest* close_session) {
1195 clear_op();
1196 if (close_session) {
1197 set_has_close_session();
1198 op_.close_session_ = close_session;
1199 }
1200 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.close_session)
1201}
1202inline ::tensorflow::CloseSessionRequest* ReplayOp::mutable_close_session() {
1203 if (!has_close_session()) {
1204 clear_op();
1205 set_has_close_session();
1206 op_.close_session_ = CreateMaybeMessage< ::tensorflow::CloseSessionRequest >(
1207 GetArenaNoVirtual());
1208 }
1209 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.close_session)
1210 return op_.close_session_;
1211}
1212
1213// .tensorflow.ListDevicesRequest list_devices = 6;
1214inline bool ReplayOp::has_list_devices() const {
1215 return op_case() == kListDevices;
1216}
1217inline void ReplayOp::set_has_list_devices() {
1218 _oneof_case_[0] = kListDevices;
1219}
1220inline ::tensorflow::ListDevicesRequest* ReplayOp::release_list_devices() {
1221 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.list_devices)
1222 if (has_list_devices()) {
1223 clear_has_op();
1224 ::tensorflow::ListDevicesRequest* temp = op_.list_devices_;
1225 if (GetArenaNoVirtual() != nullptr) {
1226 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1227 }
1228 op_.list_devices_ = nullptr;
1229 return temp;
1230 } else {
1231 return nullptr;
1232 }
1233}
1234inline const ::tensorflow::ListDevicesRequest& ReplayOp::list_devices() const {
1235 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.list_devices)
1236 return has_list_devices()
1237 ? *op_.list_devices_
1238 : *reinterpret_cast< ::tensorflow::ListDevicesRequest*>(&::tensorflow::_ListDevicesRequest_default_instance_);
1239}
1240inline ::tensorflow::ListDevicesRequest* ReplayOp::unsafe_arena_release_list_devices() {
1241 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.list_devices)
1242 if (has_list_devices()) {
1243 clear_has_op();
1244 ::tensorflow::ListDevicesRequest* temp = op_.list_devices_;
1245 op_.list_devices_ = nullptr;
1246 return temp;
1247 } else {
1248 return nullptr;
1249 }
1250}
1251inline void ReplayOp::unsafe_arena_set_allocated_list_devices(::tensorflow::ListDevicesRequest* list_devices) {
1252 clear_op();
1253 if (list_devices) {
1254 set_has_list_devices();
1255 op_.list_devices_ = list_devices;
1256 }
1257 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.list_devices)
1258}
1259inline ::tensorflow::ListDevicesRequest* ReplayOp::mutable_list_devices() {
1260 if (!has_list_devices()) {
1261 clear_op();
1262 set_has_list_devices();
1263 op_.list_devices_ = CreateMaybeMessage< ::tensorflow::ListDevicesRequest >(
1264 GetArenaNoVirtual());
1265 }
1266 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.list_devices)
1267 return op_.list_devices_;
1268}
1269
1270// .tensorflow.ResetRequest reset_request = 7;
1271inline bool ReplayOp::has_reset_request() const {
1272 return op_case() == kResetRequest;
1273}
1274inline void ReplayOp::set_has_reset_request() {
1275 _oneof_case_[0] = kResetRequest;
1276}
1277inline ::tensorflow::ResetRequest* ReplayOp::release_reset_request() {
1278 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.reset_request)
1279 if (has_reset_request()) {
1280 clear_has_op();
1281 ::tensorflow::ResetRequest* temp = op_.reset_request_;
1282 if (GetArenaNoVirtual() != nullptr) {
1283 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1284 }
1285 op_.reset_request_ = nullptr;
1286 return temp;
1287 } else {
1288 return nullptr;
1289 }
1290}
1291inline const ::tensorflow::ResetRequest& ReplayOp::reset_request() const {
1292 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.reset_request)
1293 return has_reset_request()
1294 ? *op_.reset_request_
1295 : *reinterpret_cast< ::tensorflow::ResetRequest*>(&::tensorflow::_ResetRequest_default_instance_);
1296}
1297inline ::tensorflow::ResetRequest* ReplayOp::unsafe_arena_release_reset_request() {
1298 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.reset_request)
1299 if (has_reset_request()) {
1300 clear_has_op();
1301 ::tensorflow::ResetRequest* temp = op_.reset_request_;
1302 op_.reset_request_ = nullptr;
1303 return temp;
1304 } else {
1305 return nullptr;
1306 }
1307}
1308inline void ReplayOp::unsafe_arena_set_allocated_reset_request(::tensorflow::ResetRequest* reset_request) {
1309 clear_op();
1310 if (reset_request) {
1311 set_has_reset_request();
1312 op_.reset_request_ = reset_request;
1313 }
1314 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.reset_request)
1315}
1316inline ::tensorflow::ResetRequest* ReplayOp::mutable_reset_request() {
1317 if (!has_reset_request()) {
1318 clear_op();
1319 set_has_reset_request();
1320 op_.reset_request_ = CreateMaybeMessage< ::tensorflow::ResetRequest >(
1321 GetArenaNoVirtual());
1322 }
1323 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.reset_request)
1324 return op_.reset_request_;
1325}
1326
1327// .tensorflow.MakeCallableRequest make_callable = 8;
1328inline bool ReplayOp::has_make_callable() const {
1329 return op_case() == kMakeCallable;
1330}
1331inline void ReplayOp::set_has_make_callable() {
1332 _oneof_case_[0] = kMakeCallable;
1333}
1334inline ::tensorflow::MakeCallableRequest* ReplayOp::release_make_callable() {
1335 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.make_callable)
1336 if (has_make_callable()) {
1337 clear_has_op();
1338 ::tensorflow::MakeCallableRequest* temp = op_.make_callable_;
1339 if (GetArenaNoVirtual() != nullptr) {
1340 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1341 }
1342 op_.make_callable_ = nullptr;
1343 return temp;
1344 } else {
1345 return nullptr;
1346 }
1347}
1348inline const ::tensorflow::MakeCallableRequest& ReplayOp::make_callable() const {
1349 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.make_callable)
1350 return has_make_callable()
1351 ? *op_.make_callable_
1352 : *reinterpret_cast< ::tensorflow::MakeCallableRequest*>(&::tensorflow::_MakeCallableRequest_default_instance_);
1353}
1354inline ::tensorflow::MakeCallableRequest* ReplayOp::unsafe_arena_release_make_callable() {
1355 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.make_callable)
1356 if (has_make_callable()) {
1357 clear_has_op();
1358 ::tensorflow::MakeCallableRequest* temp = op_.make_callable_;
1359 op_.make_callable_ = nullptr;
1360 return temp;
1361 } else {
1362 return nullptr;
1363 }
1364}
1365inline void ReplayOp::unsafe_arena_set_allocated_make_callable(::tensorflow::MakeCallableRequest* make_callable) {
1366 clear_op();
1367 if (make_callable) {
1368 set_has_make_callable();
1369 op_.make_callable_ = make_callable;
1370 }
1371 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.make_callable)
1372}
1373inline ::tensorflow::MakeCallableRequest* ReplayOp::mutable_make_callable() {
1374 if (!has_make_callable()) {
1375 clear_op();
1376 set_has_make_callable();
1377 op_.make_callable_ = CreateMaybeMessage< ::tensorflow::MakeCallableRequest >(
1378 GetArenaNoVirtual());
1379 }
1380 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.make_callable)
1381 return op_.make_callable_;
1382}
1383
1384// .tensorflow.RunCallableRequest run_callable = 9;
1385inline bool ReplayOp::has_run_callable() const {
1386 return op_case() == kRunCallable;
1387}
1388inline void ReplayOp::set_has_run_callable() {
1389 _oneof_case_[0] = kRunCallable;
1390}
1391inline ::tensorflow::RunCallableRequest* ReplayOp::release_run_callable() {
1392 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.run_callable)
1393 if (has_run_callable()) {
1394 clear_has_op();
1395 ::tensorflow::RunCallableRequest* temp = op_.run_callable_;
1396 if (GetArenaNoVirtual() != nullptr) {
1397 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1398 }
1399 op_.run_callable_ = nullptr;
1400 return temp;
1401 } else {
1402 return nullptr;
1403 }
1404}
1405inline const ::tensorflow::RunCallableRequest& ReplayOp::run_callable() const {
1406 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.run_callable)
1407 return has_run_callable()
1408 ? *op_.run_callable_
1409 : *reinterpret_cast< ::tensorflow::RunCallableRequest*>(&::tensorflow::_RunCallableRequest_default_instance_);
1410}
1411inline ::tensorflow::RunCallableRequest* ReplayOp::unsafe_arena_release_run_callable() {
1412 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.run_callable)
1413 if (has_run_callable()) {
1414 clear_has_op();
1415 ::tensorflow::RunCallableRequest* temp = op_.run_callable_;
1416 op_.run_callable_ = nullptr;
1417 return temp;
1418 } else {
1419 return nullptr;
1420 }
1421}
1422inline void ReplayOp::unsafe_arena_set_allocated_run_callable(::tensorflow::RunCallableRequest* run_callable) {
1423 clear_op();
1424 if (run_callable) {
1425 set_has_run_callable();
1426 op_.run_callable_ = run_callable;
1427 }
1428 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.run_callable)
1429}
1430inline ::tensorflow::RunCallableRequest* ReplayOp::mutable_run_callable() {
1431 if (!has_run_callable()) {
1432 clear_op();
1433 set_has_run_callable();
1434 op_.run_callable_ = CreateMaybeMessage< ::tensorflow::RunCallableRequest >(
1435 GetArenaNoVirtual());
1436 }
1437 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.run_callable)
1438 return op_.run_callable_;
1439}
1440
1441// .tensorflow.ReleaseCallableRequest release_callable = 10;
1442inline bool ReplayOp::has_release_callable() const {
1443 return op_case() == kReleaseCallable;
1444}
1445inline void ReplayOp::set_has_release_callable() {
1446 _oneof_case_[0] = kReleaseCallable;
1447}
1448inline ::tensorflow::ReleaseCallableRequest* ReplayOp::release_release_callable() {
1449 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.release_callable)
1450 if (has_release_callable()) {
1451 clear_has_op();
1452 ::tensorflow::ReleaseCallableRequest* temp = op_.release_callable_;
1453 if (GetArenaNoVirtual() != nullptr) {
1454 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1455 }
1456 op_.release_callable_ = nullptr;
1457 return temp;
1458 } else {
1459 return nullptr;
1460 }
1461}
1462inline const ::tensorflow::ReleaseCallableRequest& ReplayOp::release_callable() const {
1463 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.release_callable)
1464 return has_release_callable()
1465 ? *op_.release_callable_
1466 : *reinterpret_cast< ::tensorflow::ReleaseCallableRequest*>(&::tensorflow::_ReleaseCallableRequest_default_instance_);
1467}
1468inline ::tensorflow::ReleaseCallableRequest* ReplayOp::unsafe_arena_release_release_callable() {
1469 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.release_callable)
1470 if (has_release_callable()) {
1471 clear_has_op();
1472 ::tensorflow::ReleaseCallableRequest* temp = op_.release_callable_;
1473 op_.release_callable_ = nullptr;
1474 return temp;
1475 } else {
1476 return nullptr;
1477 }
1478}
1479inline void ReplayOp::unsafe_arena_set_allocated_release_callable(::tensorflow::ReleaseCallableRequest* release_callable) {
1480 clear_op();
1481 if (release_callable) {
1482 set_has_release_callable();
1483 op_.release_callable_ = release_callable;
1484 }
1485 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.release_callable)
1486}
1487inline ::tensorflow::ReleaseCallableRequest* ReplayOp::mutable_release_callable() {
1488 if (!has_release_callable()) {
1489 clear_op();
1490 set_has_release_callable();
1491 op_.release_callable_ = CreateMaybeMessage< ::tensorflow::ReleaseCallableRequest >(
1492 GetArenaNoVirtual());
1493 }
1494 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.release_callable)
1495 return op_.release_callable_;
1496}
1497
1498// .tensorflow.NewReplaySession new_replay_session = 11;
1499inline bool ReplayOp::has_new_replay_session() const {
1500 return op_case() == kNewReplaySession;
1501}
1502inline void ReplayOp::set_has_new_replay_session() {
1503 _oneof_case_[0] = kNewReplaySession;
1504}
1505inline void ReplayOp::clear_new_replay_session() {
1506 if (has_new_replay_session()) {
1507 if (GetArenaNoVirtual() == nullptr) {
1508 delete op_.new_replay_session_;
1509 }
1510 clear_has_op();
1511 }
1512}
1513inline ::tensorflow::NewReplaySession* ReplayOp::release_new_replay_session() {
1514 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.new_replay_session)
1515 if (has_new_replay_session()) {
1516 clear_has_op();
1517 ::tensorflow::NewReplaySession* temp = op_.new_replay_session_;
1518 if (GetArenaNoVirtual() != nullptr) {
1519 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1520 }
1521 op_.new_replay_session_ = nullptr;
1522 return temp;
1523 } else {
1524 return nullptr;
1525 }
1526}
1527inline const ::tensorflow::NewReplaySession& ReplayOp::new_replay_session() const {
1528 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.new_replay_session)
1529 return has_new_replay_session()
1530 ? *op_.new_replay_session_
1531 : *reinterpret_cast< ::tensorflow::NewReplaySession*>(&::tensorflow::_NewReplaySession_default_instance_);
1532}
1533inline ::tensorflow::NewReplaySession* ReplayOp::unsafe_arena_release_new_replay_session() {
1534 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.new_replay_session)
1535 if (has_new_replay_session()) {
1536 clear_has_op();
1537 ::tensorflow::NewReplaySession* temp = op_.new_replay_session_;
1538 op_.new_replay_session_ = nullptr;
1539 return temp;
1540 } else {
1541 return nullptr;
1542 }
1543}
1544inline void ReplayOp::unsafe_arena_set_allocated_new_replay_session(::tensorflow::NewReplaySession* new_replay_session) {
1545 clear_op();
1546 if (new_replay_session) {
1547 set_has_new_replay_session();
1548 op_.new_replay_session_ = new_replay_session;
1549 }
1550 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.new_replay_session)
1551}
1552inline ::tensorflow::NewReplaySession* ReplayOp::mutable_new_replay_session() {
1553 if (!has_new_replay_session()) {
1554 clear_op();
1555 set_has_new_replay_session();
1556 op_.new_replay_session_ = CreateMaybeMessage< ::tensorflow::NewReplaySession >(
1557 GetArenaNoVirtual());
1558 }
1559 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.new_replay_session)
1560 return op_.new_replay_session_;
1561}
1562
1563// .tensorflow.CreateSessionResponse create_session_response = 21;
1564inline bool ReplayOp::has_create_session_response() const {
1565 return response_case() == kCreateSessionResponse;
1566}
1567inline void ReplayOp::set_has_create_session_response() {
1568 _oneof_case_[1] = kCreateSessionResponse;
1569}
1570inline ::tensorflow::CreateSessionResponse* ReplayOp::release_create_session_response() {
1571 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.create_session_response)
1572 if (has_create_session_response()) {
1573 clear_has_response();
1574 ::tensorflow::CreateSessionResponse* temp = response_.create_session_response_;
1575 if (GetArenaNoVirtual() != nullptr) {
1576 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1577 }
1578 response_.create_session_response_ = nullptr;
1579 return temp;
1580 } else {
1581 return nullptr;
1582 }
1583}
1584inline const ::tensorflow::CreateSessionResponse& ReplayOp::create_session_response() const {
1585 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.create_session_response)
1586 return has_create_session_response()
1587 ? *response_.create_session_response_
1588 : *reinterpret_cast< ::tensorflow::CreateSessionResponse*>(&::tensorflow::_CreateSessionResponse_default_instance_);
1589}
1590inline ::tensorflow::CreateSessionResponse* ReplayOp::unsafe_arena_release_create_session_response() {
1591 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.create_session_response)
1592 if (has_create_session_response()) {
1593 clear_has_response();
1594 ::tensorflow::CreateSessionResponse* temp = response_.create_session_response_;
1595 response_.create_session_response_ = nullptr;
1596 return temp;
1597 } else {
1598 return nullptr;
1599 }
1600}
1601inline void ReplayOp::unsafe_arena_set_allocated_create_session_response(::tensorflow::CreateSessionResponse* create_session_response) {
1602 clear_response();
1603 if (create_session_response) {
1604 set_has_create_session_response();
1605 response_.create_session_response_ = create_session_response;
1606 }
1607 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.create_session_response)
1608}
1609inline ::tensorflow::CreateSessionResponse* ReplayOp::mutable_create_session_response() {
1610 if (!has_create_session_response()) {
1611 clear_response();
1612 set_has_create_session_response();
1613 response_.create_session_response_ = CreateMaybeMessage< ::tensorflow::CreateSessionResponse >(
1614 GetArenaNoVirtual());
1615 }
1616 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.create_session_response)
1617 return response_.create_session_response_;
1618}
1619
1620// .tensorflow.ExtendSessionResponse extend_session_response = 22;
1621inline bool ReplayOp::has_extend_session_response() const {
1622 return response_case() == kExtendSessionResponse;
1623}
1624inline void ReplayOp::set_has_extend_session_response() {
1625 _oneof_case_[1] = kExtendSessionResponse;
1626}
1627inline ::tensorflow::ExtendSessionResponse* ReplayOp::release_extend_session_response() {
1628 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.extend_session_response)
1629 if (has_extend_session_response()) {
1630 clear_has_response();
1631 ::tensorflow::ExtendSessionResponse* temp = response_.extend_session_response_;
1632 if (GetArenaNoVirtual() != nullptr) {
1633 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1634 }
1635 response_.extend_session_response_ = nullptr;
1636 return temp;
1637 } else {
1638 return nullptr;
1639 }
1640}
1641inline const ::tensorflow::ExtendSessionResponse& ReplayOp::extend_session_response() const {
1642 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.extend_session_response)
1643 return has_extend_session_response()
1644 ? *response_.extend_session_response_
1645 : *reinterpret_cast< ::tensorflow::ExtendSessionResponse*>(&::tensorflow::_ExtendSessionResponse_default_instance_);
1646}
1647inline ::tensorflow::ExtendSessionResponse* ReplayOp::unsafe_arena_release_extend_session_response() {
1648 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.extend_session_response)
1649 if (has_extend_session_response()) {
1650 clear_has_response();
1651 ::tensorflow::ExtendSessionResponse* temp = response_.extend_session_response_;
1652 response_.extend_session_response_ = nullptr;
1653 return temp;
1654 } else {
1655 return nullptr;
1656 }
1657}
1658inline void ReplayOp::unsafe_arena_set_allocated_extend_session_response(::tensorflow::ExtendSessionResponse* extend_session_response) {
1659 clear_response();
1660 if (extend_session_response) {
1661 set_has_extend_session_response();
1662 response_.extend_session_response_ = extend_session_response;
1663 }
1664 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.extend_session_response)
1665}
1666inline ::tensorflow::ExtendSessionResponse* ReplayOp::mutable_extend_session_response() {
1667 if (!has_extend_session_response()) {
1668 clear_response();
1669 set_has_extend_session_response();
1670 response_.extend_session_response_ = CreateMaybeMessage< ::tensorflow::ExtendSessionResponse >(
1671 GetArenaNoVirtual());
1672 }
1673 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.extend_session_response)
1674 return response_.extend_session_response_;
1675}
1676
1677// .tensorflow.PartialRunSetupResponse partial_run_setup_response = 23;
1678inline bool ReplayOp::has_partial_run_setup_response() const {
1679 return response_case() == kPartialRunSetupResponse;
1680}
1681inline void ReplayOp::set_has_partial_run_setup_response() {
1682 _oneof_case_[1] = kPartialRunSetupResponse;
1683}
1684inline ::tensorflow::PartialRunSetupResponse* ReplayOp::release_partial_run_setup_response() {
1685 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.partial_run_setup_response)
1686 if (has_partial_run_setup_response()) {
1687 clear_has_response();
1688 ::tensorflow::PartialRunSetupResponse* temp = response_.partial_run_setup_response_;
1689 if (GetArenaNoVirtual() != nullptr) {
1690 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1691 }
1692 response_.partial_run_setup_response_ = nullptr;
1693 return temp;
1694 } else {
1695 return nullptr;
1696 }
1697}
1698inline const ::tensorflow::PartialRunSetupResponse& ReplayOp::partial_run_setup_response() const {
1699 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.partial_run_setup_response)
1700 return has_partial_run_setup_response()
1701 ? *response_.partial_run_setup_response_
1702 : *reinterpret_cast< ::tensorflow::PartialRunSetupResponse*>(&::tensorflow::_PartialRunSetupResponse_default_instance_);
1703}
1704inline ::tensorflow::PartialRunSetupResponse* ReplayOp::unsafe_arena_release_partial_run_setup_response() {
1705 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.partial_run_setup_response)
1706 if (has_partial_run_setup_response()) {
1707 clear_has_response();
1708 ::tensorflow::PartialRunSetupResponse* temp = response_.partial_run_setup_response_;
1709 response_.partial_run_setup_response_ = nullptr;
1710 return temp;
1711 } else {
1712 return nullptr;
1713 }
1714}
1715inline void ReplayOp::unsafe_arena_set_allocated_partial_run_setup_response(::tensorflow::PartialRunSetupResponse* partial_run_setup_response) {
1716 clear_response();
1717 if (partial_run_setup_response) {
1718 set_has_partial_run_setup_response();
1719 response_.partial_run_setup_response_ = partial_run_setup_response;
1720 }
1721 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.partial_run_setup_response)
1722}
1723inline ::tensorflow::PartialRunSetupResponse* ReplayOp::mutable_partial_run_setup_response() {
1724 if (!has_partial_run_setup_response()) {
1725 clear_response();
1726 set_has_partial_run_setup_response();
1727 response_.partial_run_setup_response_ = CreateMaybeMessage< ::tensorflow::PartialRunSetupResponse >(
1728 GetArenaNoVirtual());
1729 }
1730 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.partial_run_setup_response)
1731 return response_.partial_run_setup_response_;
1732}
1733
1734// .tensorflow.RunStepResponse run_step_response = 24;
1735inline bool ReplayOp::has_run_step_response() const {
1736 return response_case() == kRunStepResponse;
1737}
1738inline void ReplayOp::set_has_run_step_response() {
1739 _oneof_case_[1] = kRunStepResponse;
1740}
1741inline ::tensorflow::RunStepResponse* ReplayOp::release_run_step_response() {
1742 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.run_step_response)
1743 if (has_run_step_response()) {
1744 clear_has_response();
1745 ::tensorflow::RunStepResponse* temp = response_.run_step_response_;
1746 if (GetArenaNoVirtual() != nullptr) {
1747 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1748 }
1749 response_.run_step_response_ = nullptr;
1750 return temp;
1751 } else {
1752 return nullptr;
1753 }
1754}
1755inline const ::tensorflow::RunStepResponse& ReplayOp::run_step_response() const {
1756 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.run_step_response)
1757 return has_run_step_response()
1758 ? *response_.run_step_response_
1759 : *reinterpret_cast< ::tensorflow::RunStepResponse*>(&::tensorflow::_RunStepResponse_default_instance_);
1760}
1761inline ::tensorflow::RunStepResponse* ReplayOp::unsafe_arena_release_run_step_response() {
1762 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.run_step_response)
1763 if (has_run_step_response()) {
1764 clear_has_response();
1765 ::tensorflow::RunStepResponse* temp = response_.run_step_response_;
1766 response_.run_step_response_ = nullptr;
1767 return temp;
1768 } else {
1769 return nullptr;
1770 }
1771}
1772inline void ReplayOp::unsafe_arena_set_allocated_run_step_response(::tensorflow::RunStepResponse* run_step_response) {
1773 clear_response();
1774 if (run_step_response) {
1775 set_has_run_step_response();
1776 response_.run_step_response_ = run_step_response;
1777 }
1778 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.run_step_response)
1779}
1780inline ::tensorflow::RunStepResponse* ReplayOp::mutable_run_step_response() {
1781 if (!has_run_step_response()) {
1782 clear_response();
1783 set_has_run_step_response();
1784 response_.run_step_response_ = CreateMaybeMessage< ::tensorflow::RunStepResponse >(
1785 GetArenaNoVirtual());
1786 }
1787 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.run_step_response)
1788 return response_.run_step_response_;
1789}
1790
1791// .tensorflow.CloseSessionResponse close_session_response = 25;
1792inline bool ReplayOp::has_close_session_response() const {
1793 return response_case() == kCloseSessionResponse;
1794}
1795inline void ReplayOp::set_has_close_session_response() {
1796 _oneof_case_[1] = kCloseSessionResponse;
1797}
1798inline ::tensorflow::CloseSessionResponse* ReplayOp::release_close_session_response() {
1799 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.close_session_response)
1800 if (has_close_session_response()) {
1801 clear_has_response();
1802 ::tensorflow::CloseSessionResponse* temp = response_.close_session_response_;
1803 if (GetArenaNoVirtual() != nullptr) {
1804 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1805 }
1806 response_.close_session_response_ = nullptr;
1807 return temp;
1808 } else {
1809 return nullptr;
1810 }
1811}
1812inline const ::tensorflow::CloseSessionResponse& ReplayOp::close_session_response() const {
1813 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.close_session_response)
1814 return has_close_session_response()
1815 ? *response_.close_session_response_
1816 : *reinterpret_cast< ::tensorflow::CloseSessionResponse*>(&::tensorflow::_CloseSessionResponse_default_instance_);
1817}
1818inline ::tensorflow::CloseSessionResponse* ReplayOp::unsafe_arena_release_close_session_response() {
1819 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.close_session_response)
1820 if (has_close_session_response()) {
1821 clear_has_response();
1822 ::tensorflow::CloseSessionResponse* temp = response_.close_session_response_;
1823 response_.close_session_response_ = nullptr;
1824 return temp;
1825 } else {
1826 return nullptr;
1827 }
1828}
1829inline void ReplayOp::unsafe_arena_set_allocated_close_session_response(::tensorflow::CloseSessionResponse* close_session_response) {
1830 clear_response();
1831 if (close_session_response) {
1832 set_has_close_session_response();
1833 response_.close_session_response_ = close_session_response;
1834 }
1835 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.close_session_response)
1836}
1837inline ::tensorflow::CloseSessionResponse* ReplayOp::mutable_close_session_response() {
1838 if (!has_close_session_response()) {
1839 clear_response();
1840 set_has_close_session_response();
1841 response_.close_session_response_ = CreateMaybeMessage< ::tensorflow::CloseSessionResponse >(
1842 GetArenaNoVirtual());
1843 }
1844 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.close_session_response)
1845 return response_.close_session_response_;
1846}
1847
1848// .tensorflow.ListDevicesResponse list_devices_response = 26;
1849inline bool ReplayOp::has_list_devices_response() const {
1850 return response_case() == kListDevicesResponse;
1851}
1852inline void ReplayOp::set_has_list_devices_response() {
1853 _oneof_case_[1] = kListDevicesResponse;
1854}
1855inline ::tensorflow::ListDevicesResponse* ReplayOp::release_list_devices_response() {
1856 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.list_devices_response)
1857 if (has_list_devices_response()) {
1858 clear_has_response();
1859 ::tensorflow::ListDevicesResponse* temp = response_.list_devices_response_;
1860 if (GetArenaNoVirtual() != nullptr) {
1861 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1862 }
1863 response_.list_devices_response_ = nullptr;
1864 return temp;
1865 } else {
1866 return nullptr;
1867 }
1868}
1869inline const ::tensorflow::ListDevicesResponse& ReplayOp::list_devices_response() const {
1870 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.list_devices_response)
1871 return has_list_devices_response()
1872 ? *response_.list_devices_response_
1873 : *reinterpret_cast< ::tensorflow::ListDevicesResponse*>(&::tensorflow::_ListDevicesResponse_default_instance_);
1874}
1875inline ::tensorflow::ListDevicesResponse* ReplayOp::unsafe_arena_release_list_devices_response() {
1876 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.list_devices_response)
1877 if (has_list_devices_response()) {
1878 clear_has_response();
1879 ::tensorflow::ListDevicesResponse* temp = response_.list_devices_response_;
1880 response_.list_devices_response_ = nullptr;
1881 return temp;
1882 } else {
1883 return nullptr;
1884 }
1885}
1886inline void ReplayOp::unsafe_arena_set_allocated_list_devices_response(::tensorflow::ListDevicesResponse* list_devices_response) {
1887 clear_response();
1888 if (list_devices_response) {
1889 set_has_list_devices_response();
1890 response_.list_devices_response_ = list_devices_response;
1891 }
1892 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.list_devices_response)
1893}
1894inline ::tensorflow::ListDevicesResponse* ReplayOp::mutable_list_devices_response() {
1895 if (!has_list_devices_response()) {
1896 clear_response();
1897 set_has_list_devices_response();
1898 response_.list_devices_response_ = CreateMaybeMessage< ::tensorflow::ListDevicesResponse >(
1899 GetArenaNoVirtual());
1900 }
1901 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.list_devices_response)
1902 return response_.list_devices_response_;
1903}
1904
1905// .tensorflow.ResetResponse reset_request_response = 27;
1906inline bool ReplayOp::has_reset_request_response() const {
1907 return response_case() == kResetRequestResponse;
1908}
1909inline void ReplayOp::set_has_reset_request_response() {
1910 _oneof_case_[1] = kResetRequestResponse;
1911}
1912inline ::tensorflow::ResetResponse* ReplayOp::release_reset_request_response() {
1913 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.reset_request_response)
1914 if (has_reset_request_response()) {
1915 clear_has_response();
1916 ::tensorflow::ResetResponse* temp = response_.reset_request_response_;
1917 if (GetArenaNoVirtual() != nullptr) {
1918 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1919 }
1920 response_.reset_request_response_ = nullptr;
1921 return temp;
1922 } else {
1923 return nullptr;
1924 }
1925}
1926inline const ::tensorflow::ResetResponse& ReplayOp::reset_request_response() const {
1927 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.reset_request_response)
1928 return has_reset_request_response()
1929 ? *response_.reset_request_response_
1930 : *reinterpret_cast< ::tensorflow::ResetResponse*>(&::tensorflow::_ResetResponse_default_instance_);
1931}
1932inline ::tensorflow::ResetResponse* ReplayOp::unsafe_arena_release_reset_request_response() {
1933 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.reset_request_response)
1934 if (has_reset_request_response()) {
1935 clear_has_response();
1936 ::tensorflow::ResetResponse* temp = response_.reset_request_response_;
1937 response_.reset_request_response_ = nullptr;
1938 return temp;
1939 } else {
1940 return nullptr;
1941 }
1942}
1943inline void ReplayOp::unsafe_arena_set_allocated_reset_request_response(::tensorflow::ResetResponse* reset_request_response) {
1944 clear_response();
1945 if (reset_request_response) {
1946 set_has_reset_request_response();
1947 response_.reset_request_response_ = reset_request_response;
1948 }
1949 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.reset_request_response)
1950}
1951inline ::tensorflow::ResetResponse* ReplayOp::mutable_reset_request_response() {
1952 if (!has_reset_request_response()) {
1953 clear_response();
1954 set_has_reset_request_response();
1955 response_.reset_request_response_ = CreateMaybeMessage< ::tensorflow::ResetResponse >(
1956 GetArenaNoVirtual());
1957 }
1958 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.reset_request_response)
1959 return response_.reset_request_response_;
1960}
1961
1962// .tensorflow.MakeCallableResponse make_callable_response = 28;
1963inline bool ReplayOp::has_make_callable_response() const {
1964 return response_case() == kMakeCallableResponse;
1965}
1966inline void ReplayOp::set_has_make_callable_response() {
1967 _oneof_case_[1] = kMakeCallableResponse;
1968}
1969inline ::tensorflow::MakeCallableResponse* ReplayOp::release_make_callable_response() {
1970 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.make_callable_response)
1971 if (has_make_callable_response()) {
1972 clear_has_response();
1973 ::tensorflow::MakeCallableResponse* temp = response_.make_callable_response_;
1974 if (GetArenaNoVirtual() != nullptr) {
1975 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1976 }
1977 response_.make_callable_response_ = nullptr;
1978 return temp;
1979 } else {
1980 return nullptr;
1981 }
1982}
1983inline const ::tensorflow::MakeCallableResponse& ReplayOp::make_callable_response() const {
1984 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.make_callable_response)
1985 return has_make_callable_response()
1986 ? *response_.make_callable_response_
1987 : *reinterpret_cast< ::tensorflow::MakeCallableResponse*>(&::tensorflow::_MakeCallableResponse_default_instance_);
1988}
1989inline ::tensorflow::MakeCallableResponse* ReplayOp::unsafe_arena_release_make_callable_response() {
1990 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.make_callable_response)
1991 if (has_make_callable_response()) {
1992 clear_has_response();
1993 ::tensorflow::MakeCallableResponse* temp = response_.make_callable_response_;
1994 response_.make_callable_response_ = nullptr;
1995 return temp;
1996 } else {
1997 return nullptr;
1998 }
1999}
2000inline void ReplayOp::unsafe_arena_set_allocated_make_callable_response(::tensorflow::MakeCallableResponse* make_callable_response) {
2001 clear_response();
2002 if (make_callable_response) {
2003 set_has_make_callable_response();
2004 response_.make_callable_response_ = make_callable_response;
2005 }
2006 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.make_callable_response)
2007}
2008inline ::tensorflow::MakeCallableResponse* ReplayOp::mutable_make_callable_response() {
2009 if (!has_make_callable_response()) {
2010 clear_response();
2011 set_has_make_callable_response();
2012 response_.make_callable_response_ = CreateMaybeMessage< ::tensorflow::MakeCallableResponse >(
2013 GetArenaNoVirtual());
2014 }
2015 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.make_callable_response)
2016 return response_.make_callable_response_;
2017}
2018
2019// .tensorflow.RunCallableResponse run_callable_response = 29;
2020inline bool ReplayOp::has_run_callable_response() const {
2021 return response_case() == kRunCallableResponse;
2022}
2023inline void ReplayOp::set_has_run_callable_response() {
2024 _oneof_case_[1] = kRunCallableResponse;
2025}
2026inline ::tensorflow::RunCallableResponse* ReplayOp::release_run_callable_response() {
2027 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.run_callable_response)
2028 if (has_run_callable_response()) {
2029 clear_has_response();
2030 ::tensorflow::RunCallableResponse* temp = response_.run_callable_response_;
2031 if (GetArenaNoVirtual() != nullptr) {
2032 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2033 }
2034 response_.run_callable_response_ = nullptr;
2035 return temp;
2036 } else {
2037 return nullptr;
2038 }
2039}
2040inline const ::tensorflow::RunCallableResponse& ReplayOp::run_callable_response() const {
2041 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.run_callable_response)
2042 return has_run_callable_response()
2043 ? *response_.run_callable_response_
2044 : *reinterpret_cast< ::tensorflow::RunCallableResponse*>(&::tensorflow::_RunCallableResponse_default_instance_);
2045}
2046inline ::tensorflow::RunCallableResponse* ReplayOp::unsafe_arena_release_run_callable_response() {
2047 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.run_callable_response)
2048 if (has_run_callable_response()) {
2049 clear_has_response();
2050 ::tensorflow::RunCallableResponse* temp = response_.run_callable_response_;
2051 response_.run_callable_response_ = nullptr;
2052 return temp;
2053 } else {
2054 return nullptr;
2055 }
2056}
2057inline void ReplayOp::unsafe_arena_set_allocated_run_callable_response(::tensorflow::RunCallableResponse* run_callable_response) {
2058 clear_response();
2059 if (run_callable_response) {
2060 set_has_run_callable_response();
2061 response_.run_callable_response_ = run_callable_response;
2062 }
2063 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.run_callable_response)
2064}
2065inline ::tensorflow::RunCallableResponse* ReplayOp::mutable_run_callable_response() {
2066 if (!has_run_callable_response()) {
2067 clear_response();
2068 set_has_run_callable_response();
2069 response_.run_callable_response_ = CreateMaybeMessage< ::tensorflow::RunCallableResponse >(
2070 GetArenaNoVirtual());
2071 }
2072 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.run_callable_response)
2073 return response_.run_callable_response_;
2074}
2075
2076// .tensorflow.ReleaseCallableResponse release_callable_response = 30;
2077inline bool ReplayOp::has_release_callable_response() const {
2078 return response_case() == kReleaseCallableResponse;
2079}
2080inline void ReplayOp::set_has_release_callable_response() {
2081 _oneof_case_[1] = kReleaseCallableResponse;
2082}
2083inline ::tensorflow::ReleaseCallableResponse* ReplayOp::release_release_callable_response() {
2084 // @@protoc_insertion_point(field_release:tensorflow.ReplayOp.release_callable_response)
2085 if (has_release_callable_response()) {
2086 clear_has_response();
2087 ::tensorflow::ReleaseCallableResponse* temp = response_.release_callable_response_;
2088 if (GetArenaNoVirtual() != nullptr) {
2089 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2090 }
2091 response_.release_callable_response_ = nullptr;
2092 return temp;
2093 } else {
2094 return nullptr;
2095 }
2096}
2097inline const ::tensorflow::ReleaseCallableResponse& ReplayOp::release_callable_response() const {
2098 // @@protoc_insertion_point(field_get:tensorflow.ReplayOp.release_callable_response)
2099 return has_release_callable_response()
2100 ? *response_.release_callable_response_
2101 : *reinterpret_cast< ::tensorflow::ReleaseCallableResponse*>(&::tensorflow::_ReleaseCallableResponse_default_instance_);
2102}
2103inline ::tensorflow::ReleaseCallableResponse* ReplayOp::unsafe_arena_release_release_callable_response() {
2104 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.ReplayOp.release_callable_response)
2105 if (has_release_callable_response()) {
2106 clear_has_response();
2107 ::tensorflow::ReleaseCallableResponse* temp = response_.release_callable_response_;
2108 response_.release_callable_response_ = nullptr;
2109 return temp;
2110 } else {
2111 return nullptr;
2112 }
2113}
2114inline void ReplayOp::unsafe_arena_set_allocated_release_callable_response(::tensorflow::ReleaseCallableResponse* release_callable_response) {
2115 clear_response();
2116 if (release_callable_response) {
2117 set_has_release_callable_response();
2118 response_.release_callable_response_ = release_callable_response;
2119 }
2120 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.ReplayOp.release_callable_response)
2121}
2122inline ::tensorflow::ReleaseCallableResponse* ReplayOp::mutable_release_callable_response() {
2123 if (!has_release_callable_response()) {
2124 clear_response();
2125 set_has_release_callable_response();
2126 response_.release_callable_response_ = CreateMaybeMessage< ::tensorflow::ReleaseCallableResponse >(
2127 GetArenaNoVirtual());
2128 }
2129 // @@protoc_insertion_point(field_mutable:tensorflow.ReplayOp.release_callable_response)
2130 return response_.release_callable_response_;
2131}
2132
2133inline bool ReplayOp::has_op() const {
2134 return op_case() != OP_NOT_SET;
2135}
2136inline void ReplayOp::clear_has_op() {
2137 _oneof_case_[0] = OP_NOT_SET;
2138}
2139inline bool ReplayOp::has_response() const {
2140 return response_case() != RESPONSE_NOT_SET;
2141}
2142inline void ReplayOp::clear_has_response() {
2143 _oneof_case_[1] = RESPONSE_NOT_SET;
2144}
2145inline ReplayOp::OpCase ReplayOp::op_case() const {
2146 return ReplayOp::OpCase(_oneof_case_[0]);
2147}
2148inline ReplayOp::ResponseCase ReplayOp::response_case() const {
2149 return ReplayOp::ResponseCase(_oneof_case_[1]);
2150}
2151#ifdef __GNUC__
2152 #pragma GCC diagnostic pop
2153#endif // __GNUC__
2154// -------------------------------------------------------------------
2155
2156
2157// @@protoc_insertion_point(namespace_scope)
2158
2159} // namespace tensorflow
2160
2161// @@protoc_insertion_point(global_scope)
2162
2163#include <google/protobuf/port_undef.inc>
2164#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2freplay_5flog_2eproto
2165