1// Generated by the protocol buffer compiler. DO NOT EDIT!
2// source: tensorflow/core/protobuf/debug_event.proto
3
4#ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto
5#define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto
6
7#include <limits>
8#include <string>
9
10#include <google/protobuf/port_def.inc>
11#if PROTOBUF_VERSION < 3009000
12#error This file was generated by a newer version of protoc which is
13#error incompatible with your Protocol Buffer headers. Please update
14#error your headers.
15#endif
16#if 3009002 < PROTOBUF_MIN_PROTOC_VERSION
17#error This file was generated by an older version of protoc which is
18#error incompatible with your Protocol Buffer headers. Please
19#error regenerate this file with a newer version of protoc.
20#endif
21
22#include <google/protobuf/port_undef.inc>
23#include <google/protobuf/io/coded_stream.h>
24#include <google/protobuf/arena.h>
25#include <google/protobuf/arenastring.h>
26#include <google/protobuf/generated_message_table_driven.h>
27#include <google/protobuf/generated_message_util.h>
28#include <google/protobuf/inlined_string_field.h>
29#include <google/protobuf/metadata.h>
30#include <google/protobuf/generated_message_reflection.h>
31#include <google/protobuf/message.h>
32#include <google/protobuf/repeated_field.h> // IWYU pragma: export
33#include <google/protobuf/extension_set.h> // IWYU pragma: export
34#include <google/protobuf/generated_enum_reflection.h>
35#include <google/protobuf/unknown_field_set.h>
36#include "tensorflow/core/framework/tensor.pb.h"
37#include "tensorflow/core/protobuf/graph_debug_info.pb.h"
38// @@protoc_insertion_point(includes)
39#include <google/protobuf/port_def.inc>
40#define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto
41PROTOBUF_NAMESPACE_OPEN
42namespace internal {
43class AnyMetadata;
44} // namespace internal
45PROTOBUF_NAMESPACE_CLOSE
46
47// Internal implementation detail -- do not use these members.
48struct TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto {
49 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
50 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
51 static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
52 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
53 static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[10]
54 PROTOBUF_SECTION_VARIABLE(protodesc_cold);
55 static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
56 static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
57 static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
58};
59extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
60namespace tensorflow {
61class CodeLocation;
62class CodeLocationDefaultTypeInternal;
63extern CodeLocationDefaultTypeInternal _CodeLocation_default_instance_;
64class DebugEvent;
65class DebugEventDefaultTypeInternal;
66extern DebugEventDefaultTypeInternal _DebugEvent_default_instance_;
67class DebugMetadata;
68class DebugMetadataDefaultTypeInternal;
69extern DebugMetadataDefaultTypeInternal _DebugMetadata_default_instance_;
70class DebuggedDevice;
71class DebuggedDeviceDefaultTypeInternal;
72extern DebuggedDeviceDefaultTypeInternal _DebuggedDevice_default_instance_;
73class DebuggedGraph;
74class DebuggedGraphDefaultTypeInternal;
75extern DebuggedGraphDefaultTypeInternal _DebuggedGraph_default_instance_;
76class Execution;
77class ExecutionDefaultTypeInternal;
78extern ExecutionDefaultTypeInternal _Execution_default_instance_;
79class GraphExecutionTrace;
80class GraphExecutionTraceDefaultTypeInternal;
81extern GraphExecutionTraceDefaultTypeInternal _GraphExecutionTrace_default_instance_;
82class GraphOpCreation;
83class GraphOpCreationDefaultTypeInternal;
84extern GraphOpCreationDefaultTypeInternal _GraphOpCreation_default_instance_;
85class SourceFile;
86class SourceFileDefaultTypeInternal;
87extern SourceFileDefaultTypeInternal _SourceFile_default_instance_;
88class StackFrameWithId;
89class StackFrameWithIdDefaultTypeInternal;
90extern StackFrameWithIdDefaultTypeInternal _StackFrameWithId_default_instance_;
91} // namespace tensorflow
92PROTOBUF_NAMESPACE_OPEN
93template<> ::tensorflow::CodeLocation* Arena::CreateMaybeMessage<::tensorflow::CodeLocation>(Arena*);
94template<> ::tensorflow::DebugEvent* Arena::CreateMaybeMessage<::tensorflow::DebugEvent>(Arena*);
95template<> ::tensorflow::DebugMetadata* Arena::CreateMaybeMessage<::tensorflow::DebugMetadata>(Arena*);
96template<> ::tensorflow::DebuggedDevice* Arena::CreateMaybeMessage<::tensorflow::DebuggedDevice>(Arena*);
97template<> ::tensorflow::DebuggedGraph* Arena::CreateMaybeMessage<::tensorflow::DebuggedGraph>(Arena*);
98template<> ::tensorflow::Execution* Arena::CreateMaybeMessage<::tensorflow::Execution>(Arena*);
99template<> ::tensorflow::GraphExecutionTrace* Arena::CreateMaybeMessage<::tensorflow::GraphExecutionTrace>(Arena*);
100template<> ::tensorflow::GraphOpCreation* Arena::CreateMaybeMessage<::tensorflow::GraphOpCreation>(Arena*);
101template<> ::tensorflow::SourceFile* Arena::CreateMaybeMessage<::tensorflow::SourceFile>(Arena*);
102template<> ::tensorflow::StackFrameWithId* Arena::CreateMaybeMessage<::tensorflow::StackFrameWithId>(Arena*);
103PROTOBUF_NAMESPACE_CLOSE
104namespace tensorflow {
105
106enum TensorDebugMode : int {
107 UNSPECIFIED = 0,
108 NO_TENSOR = 1,
109 CURT_HEALTH = 2,
110 CONCISE_HEALTH = 3,
111 FULL_HEALTH = 4,
112 SHAPE = 5,
113 FULL_NUMERICS = 6,
114 FULL_TENSOR = 7,
115 REDUCE_INF_NAN_THREE_SLOTS = 8,
116 TensorDebugMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
117 TensorDebugMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
118};
119bool TensorDebugMode_IsValid(int value);
120constexpr TensorDebugMode TensorDebugMode_MIN = UNSPECIFIED;
121constexpr TensorDebugMode TensorDebugMode_MAX = REDUCE_INF_NAN_THREE_SLOTS;
122constexpr int TensorDebugMode_ARRAYSIZE = TensorDebugMode_MAX + 1;
123
124const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TensorDebugMode_descriptor();
125template<typename T>
126inline const std::string& TensorDebugMode_Name(T enum_t_value) {
127 static_assert(::std::is_same<T, TensorDebugMode>::value ||
128 ::std::is_integral<T>::value,
129 "Incorrect type passed to function TensorDebugMode_Name.");
130 return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
131 TensorDebugMode_descriptor(), enum_t_value);
132}
133inline bool TensorDebugMode_Parse(
134 const std::string& name, TensorDebugMode* value) {
135 return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TensorDebugMode>(
136 TensorDebugMode_descriptor(), name, value);
137}
138// ===================================================================
139
140class DebugEvent :
141 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DebugEvent) */ {
142 public:
143 DebugEvent();
144 virtual ~DebugEvent();
145
146 DebugEvent(const DebugEvent& from);
147 DebugEvent(DebugEvent&& from) noexcept
148 : DebugEvent() {
149 *this = ::std::move(from);
150 }
151
152 inline DebugEvent& operator=(const DebugEvent& from) {
153 CopyFrom(from);
154 return *this;
155 }
156 inline DebugEvent& operator=(DebugEvent&& from) noexcept {
157 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
158 if (this != &from) InternalSwap(&from);
159 } else {
160 CopyFrom(from);
161 }
162 return *this;
163 }
164
165 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
166 return GetArenaNoVirtual();
167 }
168 inline void* GetMaybeArenaPointer() const final {
169 return MaybeArenaPtr();
170 }
171 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
172 return GetDescriptor();
173 }
174 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
175 return GetMetadataStatic().descriptor;
176 }
177 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
178 return GetMetadataStatic().reflection;
179 }
180 static const DebugEvent& default_instance();
181
182 enum WhatCase {
183 kDebugMetadata = 3,
184 kSourceFile = 4,
185 kStackFrameWithId = 6,
186 kGraphOpCreation = 7,
187 kDebuggedGraph = 8,
188 kExecution = 9,
189 kGraphExecutionTrace = 10,
190 kGraphId = 11,
191 kDebuggedDevice = 12,
192 WHAT_NOT_SET = 0,
193 };
194
195 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
196 static inline const DebugEvent* internal_default_instance() {
197 return reinterpret_cast<const DebugEvent*>(
198 &_DebugEvent_default_instance_);
199 }
200 static constexpr int kIndexInFileMessages =
201 0;
202
203 friend void swap(DebugEvent& a, DebugEvent& b) {
204 a.Swap(&b);
205 }
206 inline void Swap(DebugEvent* other) {
207 if (other == this) return;
208 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
209 InternalSwap(other);
210 } else {
211 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
212 }
213 }
214 void UnsafeArenaSwap(DebugEvent* other) {
215 if (other == this) return;
216 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
217 InternalSwap(other);
218 }
219
220 // implements Message ----------------------------------------------
221
222 inline DebugEvent* New() const final {
223 return CreateMaybeMessage<DebugEvent>(nullptr);
224 }
225
226 DebugEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
227 return CreateMaybeMessage<DebugEvent>(arena);
228 }
229 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
230 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
231 void CopyFrom(const DebugEvent& from);
232 void MergeFrom(const DebugEvent& from);
233 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
234 bool IsInitialized() const final;
235
236 size_t ByteSizeLong() const final;
237 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
238 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
239 #else
240 bool MergePartialFromCodedStream(
241 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
242 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
243 void SerializeWithCachedSizes(
244 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
245 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
246 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
247 int GetCachedSize() const final { return _cached_size_.Get(); }
248
249 private:
250 inline void SharedCtor();
251 inline void SharedDtor();
252 void SetCachedSize(int size) const final;
253 void InternalSwap(DebugEvent* other);
254 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
255 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
256 return "tensorflow.DebugEvent";
257 }
258 protected:
259 explicit DebugEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena);
260 private:
261 static void ArenaDtor(void* object);
262 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
263 private:
264 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
265 return _internal_metadata_.arena();
266 }
267 inline void* MaybeArenaPtr() const {
268 return _internal_metadata_.raw_arena_ptr();
269 }
270 public:
271
272 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
273 private:
274 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
275 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
276 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
277 }
278
279 public:
280
281 // nested types ----------------------------------------------------
282
283 // accessors -------------------------------------------------------
284
285 enum : int {
286 kWallTimeFieldNumber = 1,
287 kStepFieldNumber = 2,
288 kDebugMetadataFieldNumber = 3,
289 kSourceFileFieldNumber = 4,
290 kStackFrameWithIdFieldNumber = 6,
291 kGraphOpCreationFieldNumber = 7,
292 kDebuggedGraphFieldNumber = 8,
293 kExecutionFieldNumber = 9,
294 kGraphExecutionTraceFieldNumber = 10,
295 kGraphIdFieldNumber = 11,
296 kDebuggedDeviceFieldNumber = 12,
297 };
298 // double wall_time = 1;
299 void clear_wall_time();
300 double wall_time() const;
301 void set_wall_time(double value);
302
303 // int64 step = 2;
304 void clear_step();
305 ::PROTOBUF_NAMESPACE_ID::int64 step() const;
306 void set_step(::PROTOBUF_NAMESPACE_ID::int64 value);
307
308 // .tensorflow.DebugMetadata debug_metadata = 3;
309 bool has_debug_metadata() const;
310 void clear_debug_metadata();
311 const ::tensorflow::DebugMetadata& debug_metadata() const;
312 ::tensorflow::DebugMetadata* release_debug_metadata();
313 ::tensorflow::DebugMetadata* mutable_debug_metadata();
314 void set_allocated_debug_metadata(::tensorflow::DebugMetadata* debug_metadata);
315 void unsafe_arena_set_allocated_debug_metadata(
316 ::tensorflow::DebugMetadata* debug_metadata);
317 ::tensorflow::DebugMetadata* unsafe_arena_release_debug_metadata();
318
319 // .tensorflow.SourceFile source_file = 4;
320 bool has_source_file() const;
321 void clear_source_file();
322 const ::tensorflow::SourceFile& source_file() const;
323 ::tensorflow::SourceFile* release_source_file();
324 ::tensorflow::SourceFile* mutable_source_file();
325 void set_allocated_source_file(::tensorflow::SourceFile* source_file);
326 void unsafe_arena_set_allocated_source_file(
327 ::tensorflow::SourceFile* source_file);
328 ::tensorflow::SourceFile* unsafe_arena_release_source_file();
329
330 // .tensorflow.StackFrameWithId stack_frame_with_id = 6;
331 bool has_stack_frame_with_id() const;
332 void clear_stack_frame_with_id();
333 const ::tensorflow::StackFrameWithId& stack_frame_with_id() const;
334 ::tensorflow::StackFrameWithId* release_stack_frame_with_id();
335 ::tensorflow::StackFrameWithId* mutable_stack_frame_with_id();
336 void set_allocated_stack_frame_with_id(::tensorflow::StackFrameWithId* stack_frame_with_id);
337 void unsafe_arena_set_allocated_stack_frame_with_id(
338 ::tensorflow::StackFrameWithId* stack_frame_with_id);
339 ::tensorflow::StackFrameWithId* unsafe_arena_release_stack_frame_with_id();
340
341 // .tensorflow.GraphOpCreation graph_op_creation = 7;
342 bool has_graph_op_creation() const;
343 void clear_graph_op_creation();
344 const ::tensorflow::GraphOpCreation& graph_op_creation() const;
345 ::tensorflow::GraphOpCreation* release_graph_op_creation();
346 ::tensorflow::GraphOpCreation* mutable_graph_op_creation();
347 void set_allocated_graph_op_creation(::tensorflow::GraphOpCreation* graph_op_creation);
348 void unsafe_arena_set_allocated_graph_op_creation(
349 ::tensorflow::GraphOpCreation* graph_op_creation);
350 ::tensorflow::GraphOpCreation* unsafe_arena_release_graph_op_creation();
351
352 // .tensorflow.DebuggedGraph debugged_graph = 8;
353 bool has_debugged_graph() const;
354 void clear_debugged_graph();
355 const ::tensorflow::DebuggedGraph& debugged_graph() const;
356 ::tensorflow::DebuggedGraph* release_debugged_graph();
357 ::tensorflow::DebuggedGraph* mutable_debugged_graph();
358 void set_allocated_debugged_graph(::tensorflow::DebuggedGraph* debugged_graph);
359 void unsafe_arena_set_allocated_debugged_graph(
360 ::tensorflow::DebuggedGraph* debugged_graph);
361 ::tensorflow::DebuggedGraph* unsafe_arena_release_debugged_graph();
362
363 // .tensorflow.Execution execution = 9;
364 bool has_execution() const;
365 void clear_execution();
366 const ::tensorflow::Execution& execution() const;
367 ::tensorflow::Execution* release_execution();
368 ::tensorflow::Execution* mutable_execution();
369 void set_allocated_execution(::tensorflow::Execution* execution);
370 void unsafe_arena_set_allocated_execution(
371 ::tensorflow::Execution* execution);
372 ::tensorflow::Execution* unsafe_arena_release_execution();
373
374 // .tensorflow.GraphExecutionTrace graph_execution_trace = 10;
375 bool has_graph_execution_trace() const;
376 void clear_graph_execution_trace();
377 const ::tensorflow::GraphExecutionTrace& graph_execution_trace() const;
378 ::tensorflow::GraphExecutionTrace* release_graph_execution_trace();
379 ::tensorflow::GraphExecutionTrace* mutable_graph_execution_trace();
380 void set_allocated_graph_execution_trace(::tensorflow::GraphExecutionTrace* graph_execution_trace);
381 void unsafe_arena_set_allocated_graph_execution_trace(
382 ::tensorflow::GraphExecutionTrace* graph_execution_trace);
383 ::tensorflow::GraphExecutionTrace* unsafe_arena_release_graph_execution_trace();
384
385 // string graph_id = 11;
386 private:
387 bool has_graph_id() const;
388 public:
389 void clear_graph_id();
390 const std::string& graph_id() const;
391 void set_graph_id(const std::string& value);
392 void set_graph_id(std::string&& value);
393 void set_graph_id(const char* value);
394 void set_graph_id(const char* value, size_t size);
395 std::string* mutable_graph_id();
396 std::string* release_graph_id();
397 void set_allocated_graph_id(std::string* graph_id);
398 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
399 " string fields are deprecated and will be removed in a"
400 " future release.")
401 std::string* unsafe_arena_release_graph_id();
402 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
403 " string fields are deprecated and will be removed in a"
404 " future release.")
405 void unsafe_arena_set_allocated_graph_id(
406 std::string* graph_id);
407
408 // .tensorflow.DebuggedDevice debugged_device = 12;
409 bool has_debugged_device() const;
410 void clear_debugged_device();
411 const ::tensorflow::DebuggedDevice& debugged_device() const;
412 ::tensorflow::DebuggedDevice* release_debugged_device();
413 ::tensorflow::DebuggedDevice* mutable_debugged_device();
414 void set_allocated_debugged_device(::tensorflow::DebuggedDevice* debugged_device);
415 void unsafe_arena_set_allocated_debugged_device(
416 ::tensorflow::DebuggedDevice* debugged_device);
417 ::tensorflow::DebuggedDevice* unsafe_arena_release_debugged_device();
418
419 void clear_what();
420 WhatCase what_case() const;
421 // @@protoc_insertion_point(class_scope:tensorflow.DebugEvent)
422 private:
423 class _Internal;
424 void set_has_debug_metadata();
425 void set_has_source_file();
426 void set_has_stack_frame_with_id();
427 void set_has_graph_op_creation();
428 void set_has_debugged_graph();
429 void set_has_execution();
430 void set_has_graph_execution_trace();
431 void set_has_graph_id();
432 void set_has_debugged_device();
433
434 inline bool has_what() const;
435 inline void clear_has_what();
436
437 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
438 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
439 typedef void InternalArenaConstructable_;
440 typedef void DestructorSkippable_;
441 double wall_time_;
442 ::PROTOBUF_NAMESPACE_ID::int64 step_;
443 union WhatUnion {
444 WhatUnion() {}
445 ::tensorflow::DebugMetadata* debug_metadata_;
446 ::tensorflow::SourceFile* source_file_;
447 ::tensorflow::StackFrameWithId* stack_frame_with_id_;
448 ::tensorflow::GraphOpCreation* graph_op_creation_;
449 ::tensorflow::DebuggedGraph* debugged_graph_;
450 ::tensorflow::Execution* execution_;
451 ::tensorflow::GraphExecutionTrace* graph_execution_trace_;
452 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_id_;
453 ::tensorflow::DebuggedDevice* debugged_device_;
454 } what_;
455 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
456 ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
457
458 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
459};
460// -------------------------------------------------------------------
461
462class DebugMetadata :
463 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DebugMetadata) */ {
464 public:
465 DebugMetadata();
466 virtual ~DebugMetadata();
467
468 DebugMetadata(const DebugMetadata& from);
469 DebugMetadata(DebugMetadata&& from) noexcept
470 : DebugMetadata() {
471 *this = ::std::move(from);
472 }
473
474 inline DebugMetadata& operator=(const DebugMetadata& from) {
475 CopyFrom(from);
476 return *this;
477 }
478 inline DebugMetadata& operator=(DebugMetadata&& from) noexcept {
479 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
480 if (this != &from) InternalSwap(&from);
481 } else {
482 CopyFrom(from);
483 }
484 return *this;
485 }
486
487 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
488 return GetArenaNoVirtual();
489 }
490 inline void* GetMaybeArenaPointer() const final {
491 return MaybeArenaPtr();
492 }
493 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
494 return GetDescriptor();
495 }
496 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
497 return GetMetadataStatic().descriptor;
498 }
499 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
500 return GetMetadataStatic().reflection;
501 }
502 static const DebugMetadata& default_instance();
503
504 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
505 static inline const DebugMetadata* internal_default_instance() {
506 return reinterpret_cast<const DebugMetadata*>(
507 &_DebugMetadata_default_instance_);
508 }
509 static constexpr int kIndexInFileMessages =
510 1;
511
512 friend void swap(DebugMetadata& a, DebugMetadata& b) {
513 a.Swap(&b);
514 }
515 inline void Swap(DebugMetadata* other) {
516 if (other == this) return;
517 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
518 InternalSwap(other);
519 } else {
520 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
521 }
522 }
523 void UnsafeArenaSwap(DebugMetadata* other) {
524 if (other == this) return;
525 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
526 InternalSwap(other);
527 }
528
529 // implements Message ----------------------------------------------
530
531 inline DebugMetadata* New() const final {
532 return CreateMaybeMessage<DebugMetadata>(nullptr);
533 }
534
535 DebugMetadata* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
536 return CreateMaybeMessage<DebugMetadata>(arena);
537 }
538 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
539 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
540 void CopyFrom(const DebugMetadata& from);
541 void MergeFrom(const DebugMetadata& from);
542 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
543 bool IsInitialized() const final;
544
545 size_t ByteSizeLong() const final;
546 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
547 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
548 #else
549 bool MergePartialFromCodedStream(
550 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
551 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
552 void SerializeWithCachedSizes(
553 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
554 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
555 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
556 int GetCachedSize() const final { return _cached_size_.Get(); }
557
558 private:
559 inline void SharedCtor();
560 inline void SharedDtor();
561 void SetCachedSize(int size) const final;
562 void InternalSwap(DebugMetadata* other);
563 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
564 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
565 return "tensorflow.DebugMetadata";
566 }
567 protected:
568 explicit DebugMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena);
569 private:
570 static void ArenaDtor(void* object);
571 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
572 private:
573 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
574 return _internal_metadata_.arena();
575 }
576 inline void* MaybeArenaPtr() const {
577 return _internal_metadata_.raw_arena_ptr();
578 }
579 public:
580
581 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
582 private:
583 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
584 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
585 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
586 }
587
588 public:
589
590 // nested types ----------------------------------------------------
591
592 // accessors -------------------------------------------------------
593
594 enum : int {
595 kTensorflowVersionFieldNumber = 1,
596 kFileVersionFieldNumber = 2,
597 kTfdbgRunIdFieldNumber = 3,
598 };
599 // string tensorflow_version = 1;
600 void clear_tensorflow_version();
601 const std::string& tensorflow_version() const;
602 void set_tensorflow_version(const std::string& value);
603 void set_tensorflow_version(std::string&& value);
604 void set_tensorflow_version(const char* value);
605 void set_tensorflow_version(const char* value, size_t size);
606 std::string* mutable_tensorflow_version();
607 std::string* release_tensorflow_version();
608 void set_allocated_tensorflow_version(std::string* tensorflow_version);
609 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
610 " string fields are deprecated and will be removed in a"
611 " future release.")
612 std::string* unsafe_arena_release_tensorflow_version();
613 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
614 " string fields are deprecated and will be removed in a"
615 " future release.")
616 void unsafe_arena_set_allocated_tensorflow_version(
617 std::string* tensorflow_version);
618
619 // string file_version = 2;
620 void clear_file_version();
621 const std::string& file_version() const;
622 void set_file_version(const std::string& value);
623 void set_file_version(std::string&& value);
624 void set_file_version(const char* value);
625 void set_file_version(const char* value, size_t size);
626 std::string* mutable_file_version();
627 std::string* release_file_version();
628 void set_allocated_file_version(std::string* file_version);
629 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
630 " string fields are deprecated and will be removed in a"
631 " future release.")
632 std::string* unsafe_arena_release_file_version();
633 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
634 " string fields are deprecated and will be removed in a"
635 " future release.")
636 void unsafe_arena_set_allocated_file_version(
637 std::string* file_version);
638
639 // string tfdbg_run_id = 3;
640 void clear_tfdbg_run_id();
641 const std::string& tfdbg_run_id() const;
642 void set_tfdbg_run_id(const std::string& value);
643 void set_tfdbg_run_id(std::string&& value);
644 void set_tfdbg_run_id(const char* value);
645 void set_tfdbg_run_id(const char* value, size_t size);
646 std::string* mutable_tfdbg_run_id();
647 std::string* release_tfdbg_run_id();
648 void set_allocated_tfdbg_run_id(std::string* tfdbg_run_id);
649 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
650 " string fields are deprecated and will be removed in a"
651 " future release.")
652 std::string* unsafe_arena_release_tfdbg_run_id();
653 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
654 " string fields are deprecated and will be removed in a"
655 " future release.")
656 void unsafe_arena_set_allocated_tfdbg_run_id(
657 std::string* tfdbg_run_id);
658
659 // @@protoc_insertion_point(class_scope:tensorflow.DebugMetadata)
660 private:
661 class _Internal;
662
663 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
664 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
665 typedef void InternalArenaConstructable_;
666 typedef void DestructorSkippable_;
667 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tensorflow_version_;
668 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_version_;
669 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tfdbg_run_id_;
670 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
671 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
672};
673// -------------------------------------------------------------------
674
675class SourceFile :
676 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.SourceFile) */ {
677 public:
678 SourceFile();
679 virtual ~SourceFile();
680
681 SourceFile(const SourceFile& from);
682 SourceFile(SourceFile&& from) noexcept
683 : SourceFile() {
684 *this = ::std::move(from);
685 }
686
687 inline SourceFile& operator=(const SourceFile& from) {
688 CopyFrom(from);
689 return *this;
690 }
691 inline SourceFile& operator=(SourceFile&& from) noexcept {
692 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
693 if (this != &from) InternalSwap(&from);
694 } else {
695 CopyFrom(from);
696 }
697 return *this;
698 }
699
700 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
701 return GetArenaNoVirtual();
702 }
703 inline void* GetMaybeArenaPointer() const final {
704 return MaybeArenaPtr();
705 }
706 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
707 return GetDescriptor();
708 }
709 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
710 return GetMetadataStatic().descriptor;
711 }
712 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
713 return GetMetadataStatic().reflection;
714 }
715 static const SourceFile& default_instance();
716
717 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
718 static inline const SourceFile* internal_default_instance() {
719 return reinterpret_cast<const SourceFile*>(
720 &_SourceFile_default_instance_);
721 }
722 static constexpr int kIndexInFileMessages =
723 2;
724
725 friend void swap(SourceFile& a, SourceFile& b) {
726 a.Swap(&b);
727 }
728 inline void Swap(SourceFile* other) {
729 if (other == this) return;
730 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
731 InternalSwap(other);
732 } else {
733 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
734 }
735 }
736 void UnsafeArenaSwap(SourceFile* other) {
737 if (other == this) return;
738 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
739 InternalSwap(other);
740 }
741
742 // implements Message ----------------------------------------------
743
744 inline SourceFile* New() const final {
745 return CreateMaybeMessage<SourceFile>(nullptr);
746 }
747
748 SourceFile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
749 return CreateMaybeMessage<SourceFile>(arena);
750 }
751 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
752 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
753 void CopyFrom(const SourceFile& from);
754 void MergeFrom(const SourceFile& from);
755 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
756 bool IsInitialized() const final;
757
758 size_t ByteSizeLong() const final;
759 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
760 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
761 #else
762 bool MergePartialFromCodedStream(
763 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
764 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
765 void SerializeWithCachedSizes(
766 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
767 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
768 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
769 int GetCachedSize() const final { return _cached_size_.Get(); }
770
771 private:
772 inline void SharedCtor();
773 inline void SharedDtor();
774 void SetCachedSize(int size) const final;
775 void InternalSwap(SourceFile* other);
776 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
777 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
778 return "tensorflow.SourceFile";
779 }
780 protected:
781 explicit SourceFile(::PROTOBUF_NAMESPACE_ID::Arena* arena);
782 private:
783 static void ArenaDtor(void* object);
784 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
785 private:
786 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
787 return _internal_metadata_.arena();
788 }
789 inline void* MaybeArenaPtr() const {
790 return _internal_metadata_.raw_arena_ptr();
791 }
792 public:
793
794 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
795 private:
796 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
797 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
798 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
799 }
800
801 public:
802
803 // nested types ----------------------------------------------------
804
805 // accessors -------------------------------------------------------
806
807 enum : int {
808 kLinesFieldNumber = 3,
809 kFilePathFieldNumber = 1,
810 kHostNameFieldNumber = 2,
811 };
812 // repeated string lines = 3;
813 int lines_size() const;
814 void clear_lines();
815 const std::string& lines(int index) const;
816 std::string* mutable_lines(int index);
817 void set_lines(int index, const std::string& value);
818 void set_lines(int index, std::string&& value);
819 void set_lines(int index, const char* value);
820 void set_lines(int index, const char* value, size_t size);
821 std::string* add_lines();
822 void add_lines(const std::string& value);
823 void add_lines(std::string&& value);
824 void add_lines(const char* value);
825 void add_lines(const char* value, size_t size);
826 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& lines() const;
827 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_lines();
828
829 // string file_path = 1;
830 void clear_file_path();
831 const std::string& file_path() const;
832 void set_file_path(const std::string& value);
833 void set_file_path(std::string&& value);
834 void set_file_path(const char* value);
835 void set_file_path(const char* value, size_t size);
836 std::string* mutable_file_path();
837 std::string* release_file_path();
838 void set_allocated_file_path(std::string* file_path);
839 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
840 " string fields are deprecated and will be removed in a"
841 " future release.")
842 std::string* unsafe_arena_release_file_path();
843 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
844 " string fields are deprecated and will be removed in a"
845 " future release.")
846 void unsafe_arena_set_allocated_file_path(
847 std::string* file_path);
848
849 // string host_name = 2;
850 void clear_host_name();
851 const std::string& host_name() const;
852 void set_host_name(const std::string& value);
853 void set_host_name(std::string&& value);
854 void set_host_name(const char* value);
855 void set_host_name(const char* value, size_t size);
856 std::string* mutable_host_name();
857 std::string* release_host_name();
858 void set_allocated_host_name(std::string* host_name);
859 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
860 " string fields are deprecated and will be removed in a"
861 " future release.")
862 std::string* unsafe_arena_release_host_name();
863 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
864 " string fields are deprecated and will be removed in a"
865 " future release.")
866 void unsafe_arena_set_allocated_host_name(
867 std::string* host_name);
868
869 // @@protoc_insertion_point(class_scope:tensorflow.SourceFile)
870 private:
871 class _Internal;
872
873 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
874 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
875 typedef void InternalArenaConstructable_;
876 typedef void DestructorSkippable_;
877 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> lines_;
878 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_path_;
879 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_name_;
880 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
881 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
882};
883// -------------------------------------------------------------------
884
885class StackFrameWithId :
886 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.StackFrameWithId) */ {
887 public:
888 StackFrameWithId();
889 virtual ~StackFrameWithId();
890
891 StackFrameWithId(const StackFrameWithId& from);
892 StackFrameWithId(StackFrameWithId&& from) noexcept
893 : StackFrameWithId() {
894 *this = ::std::move(from);
895 }
896
897 inline StackFrameWithId& operator=(const StackFrameWithId& from) {
898 CopyFrom(from);
899 return *this;
900 }
901 inline StackFrameWithId& operator=(StackFrameWithId&& from) noexcept {
902 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
903 if (this != &from) InternalSwap(&from);
904 } else {
905 CopyFrom(from);
906 }
907 return *this;
908 }
909
910 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
911 return GetArenaNoVirtual();
912 }
913 inline void* GetMaybeArenaPointer() const final {
914 return MaybeArenaPtr();
915 }
916 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
917 return GetDescriptor();
918 }
919 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
920 return GetMetadataStatic().descriptor;
921 }
922 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
923 return GetMetadataStatic().reflection;
924 }
925 static const StackFrameWithId& default_instance();
926
927 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
928 static inline const StackFrameWithId* internal_default_instance() {
929 return reinterpret_cast<const StackFrameWithId*>(
930 &_StackFrameWithId_default_instance_);
931 }
932 static constexpr int kIndexInFileMessages =
933 3;
934
935 friend void swap(StackFrameWithId& a, StackFrameWithId& b) {
936 a.Swap(&b);
937 }
938 inline void Swap(StackFrameWithId* other) {
939 if (other == this) return;
940 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
941 InternalSwap(other);
942 } else {
943 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
944 }
945 }
946 void UnsafeArenaSwap(StackFrameWithId* other) {
947 if (other == this) return;
948 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
949 InternalSwap(other);
950 }
951
952 // implements Message ----------------------------------------------
953
954 inline StackFrameWithId* New() const final {
955 return CreateMaybeMessage<StackFrameWithId>(nullptr);
956 }
957
958 StackFrameWithId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
959 return CreateMaybeMessage<StackFrameWithId>(arena);
960 }
961 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
962 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
963 void CopyFrom(const StackFrameWithId& from);
964 void MergeFrom(const StackFrameWithId& from);
965 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
966 bool IsInitialized() const final;
967
968 size_t ByteSizeLong() const final;
969 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
970 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
971 #else
972 bool MergePartialFromCodedStream(
973 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
974 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
975 void SerializeWithCachedSizes(
976 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
977 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
978 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
979 int GetCachedSize() const final { return _cached_size_.Get(); }
980
981 private:
982 inline void SharedCtor();
983 inline void SharedDtor();
984 void SetCachedSize(int size) const final;
985 void InternalSwap(StackFrameWithId* other);
986 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
987 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
988 return "tensorflow.StackFrameWithId";
989 }
990 protected:
991 explicit StackFrameWithId(::PROTOBUF_NAMESPACE_ID::Arena* arena);
992 private:
993 static void ArenaDtor(void* object);
994 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
995 private:
996 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
997 return _internal_metadata_.arena();
998 }
999 inline void* MaybeArenaPtr() const {
1000 return _internal_metadata_.raw_arena_ptr();
1001 }
1002 public:
1003
1004 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1005 private:
1006 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1007 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
1008 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
1009 }
1010
1011 public:
1012
1013 // nested types ----------------------------------------------------
1014
1015 // accessors -------------------------------------------------------
1016
1017 enum : int {
1018 kIdFieldNumber = 1,
1019 kFileLineColFieldNumber = 2,
1020 };
1021 // string id = 1;
1022 void clear_id();
1023 const std::string& id() const;
1024 void set_id(const std::string& value);
1025 void set_id(std::string&& value);
1026 void set_id(const char* value);
1027 void set_id(const char* value, size_t size);
1028 std::string* mutable_id();
1029 std::string* release_id();
1030 void set_allocated_id(std::string* id);
1031 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1032 " string fields are deprecated and will be removed in a"
1033 " future release.")
1034 std::string* unsafe_arena_release_id();
1035 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1036 " string fields are deprecated and will be removed in a"
1037 " future release.")
1038 void unsafe_arena_set_allocated_id(
1039 std::string* id);
1040
1041 // .tensorflow.GraphDebugInfo.FileLineCol file_line_col = 2;
1042 bool has_file_line_col() const;
1043 void clear_file_line_col();
1044 const ::tensorflow::GraphDebugInfo_FileLineCol& file_line_col() const;
1045 ::tensorflow::GraphDebugInfo_FileLineCol* release_file_line_col();
1046 ::tensorflow::GraphDebugInfo_FileLineCol* mutable_file_line_col();
1047 void set_allocated_file_line_col(::tensorflow::GraphDebugInfo_FileLineCol* file_line_col);
1048 void unsafe_arena_set_allocated_file_line_col(
1049 ::tensorflow::GraphDebugInfo_FileLineCol* file_line_col);
1050 ::tensorflow::GraphDebugInfo_FileLineCol* unsafe_arena_release_file_line_col();
1051
1052 // @@protoc_insertion_point(class_scope:tensorflow.StackFrameWithId)
1053 private:
1054 class _Internal;
1055
1056 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1057 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1058 typedef void InternalArenaConstructable_;
1059 typedef void DestructorSkippable_;
1060 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
1061 ::tensorflow::GraphDebugInfo_FileLineCol* file_line_col_;
1062 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1063 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
1064};
1065// -------------------------------------------------------------------
1066
1067class CodeLocation :
1068 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.CodeLocation) */ {
1069 public:
1070 CodeLocation();
1071 virtual ~CodeLocation();
1072
1073 CodeLocation(const CodeLocation& from);
1074 CodeLocation(CodeLocation&& from) noexcept
1075 : CodeLocation() {
1076 *this = ::std::move(from);
1077 }
1078
1079 inline CodeLocation& operator=(const CodeLocation& from) {
1080 CopyFrom(from);
1081 return *this;
1082 }
1083 inline CodeLocation& operator=(CodeLocation&& from) noexcept {
1084 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1085 if (this != &from) InternalSwap(&from);
1086 } else {
1087 CopyFrom(from);
1088 }
1089 return *this;
1090 }
1091
1092 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1093 return GetArenaNoVirtual();
1094 }
1095 inline void* GetMaybeArenaPointer() const final {
1096 return MaybeArenaPtr();
1097 }
1098 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1099 return GetDescriptor();
1100 }
1101 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1102 return GetMetadataStatic().descriptor;
1103 }
1104 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1105 return GetMetadataStatic().reflection;
1106 }
1107 static const CodeLocation& default_instance();
1108
1109 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1110 static inline const CodeLocation* internal_default_instance() {
1111 return reinterpret_cast<const CodeLocation*>(
1112 &_CodeLocation_default_instance_);
1113 }
1114 static constexpr int kIndexInFileMessages =
1115 4;
1116
1117 friend void swap(CodeLocation& a, CodeLocation& b) {
1118 a.Swap(&b);
1119 }
1120 inline void Swap(CodeLocation* other) {
1121 if (other == this) return;
1122 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1123 InternalSwap(other);
1124 } else {
1125 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1126 }
1127 }
1128 void UnsafeArenaSwap(CodeLocation* other) {
1129 if (other == this) return;
1130 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1131 InternalSwap(other);
1132 }
1133
1134 // implements Message ----------------------------------------------
1135
1136 inline CodeLocation* New() const final {
1137 return CreateMaybeMessage<CodeLocation>(nullptr);
1138 }
1139
1140 CodeLocation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1141 return CreateMaybeMessage<CodeLocation>(arena);
1142 }
1143 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1144 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1145 void CopyFrom(const CodeLocation& from);
1146 void MergeFrom(const CodeLocation& from);
1147 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1148 bool IsInitialized() const final;
1149
1150 size_t ByteSizeLong() const final;
1151 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1152 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1153 #else
1154 bool MergePartialFromCodedStream(
1155 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1156 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1157 void SerializeWithCachedSizes(
1158 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1159 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1160 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1161 int GetCachedSize() const final { return _cached_size_.Get(); }
1162
1163 private:
1164 inline void SharedCtor();
1165 inline void SharedDtor();
1166 void SetCachedSize(int size) const final;
1167 void InternalSwap(CodeLocation* other);
1168 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1169 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1170 return "tensorflow.CodeLocation";
1171 }
1172 protected:
1173 explicit CodeLocation(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1174 private:
1175 static void ArenaDtor(void* object);
1176 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1177 private:
1178 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1179 return _internal_metadata_.arena();
1180 }
1181 inline void* MaybeArenaPtr() const {
1182 return _internal_metadata_.raw_arena_ptr();
1183 }
1184 public:
1185
1186 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1187 private:
1188 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1189 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
1190 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
1191 }
1192
1193 public:
1194
1195 // nested types ----------------------------------------------------
1196
1197 // accessors -------------------------------------------------------
1198
1199 enum : int {
1200 kStackFrameIdsFieldNumber = 2,
1201 kHostNameFieldNumber = 1,
1202 };
1203 // repeated string stack_frame_ids = 2;
1204 int stack_frame_ids_size() const;
1205 void clear_stack_frame_ids();
1206 const std::string& stack_frame_ids(int index) const;
1207 std::string* mutable_stack_frame_ids(int index);
1208 void set_stack_frame_ids(int index, const std::string& value);
1209 void set_stack_frame_ids(int index, std::string&& value);
1210 void set_stack_frame_ids(int index, const char* value);
1211 void set_stack_frame_ids(int index, const char* value, size_t size);
1212 std::string* add_stack_frame_ids();
1213 void add_stack_frame_ids(const std::string& value);
1214 void add_stack_frame_ids(std::string&& value);
1215 void add_stack_frame_ids(const char* value);
1216 void add_stack_frame_ids(const char* value, size_t size);
1217 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& stack_frame_ids() const;
1218 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_stack_frame_ids();
1219
1220 // string host_name = 1;
1221 void clear_host_name();
1222 const std::string& host_name() const;
1223 void set_host_name(const std::string& value);
1224 void set_host_name(std::string&& value);
1225 void set_host_name(const char* value);
1226 void set_host_name(const char* value, size_t size);
1227 std::string* mutable_host_name();
1228 std::string* release_host_name();
1229 void set_allocated_host_name(std::string* host_name);
1230 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1231 " string fields are deprecated and will be removed in a"
1232 " future release.")
1233 std::string* unsafe_arena_release_host_name();
1234 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1235 " string fields are deprecated and will be removed in a"
1236 " future release.")
1237 void unsafe_arena_set_allocated_host_name(
1238 std::string* host_name);
1239
1240 // @@protoc_insertion_point(class_scope:tensorflow.CodeLocation)
1241 private:
1242 class _Internal;
1243
1244 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1245 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1246 typedef void InternalArenaConstructable_;
1247 typedef void DestructorSkippable_;
1248 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> stack_frame_ids_;
1249 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_name_;
1250 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1251 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
1252};
1253// -------------------------------------------------------------------
1254
1255class GraphOpCreation :
1256 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphOpCreation) */ {
1257 public:
1258 GraphOpCreation();
1259 virtual ~GraphOpCreation();
1260
1261 GraphOpCreation(const GraphOpCreation& from);
1262 GraphOpCreation(GraphOpCreation&& from) noexcept
1263 : GraphOpCreation() {
1264 *this = ::std::move(from);
1265 }
1266
1267 inline GraphOpCreation& operator=(const GraphOpCreation& from) {
1268 CopyFrom(from);
1269 return *this;
1270 }
1271 inline GraphOpCreation& operator=(GraphOpCreation&& from) noexcept {
1272 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1273 if (this != &from) InternalSwap(&from);
1274 } else {
1275 CopyFrom(from);
1276 }
1277 return *this;
1278 }
1279
1280 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1281 return GetArenaNoVirtual();
1282 }
1283 inline void* GetMaybeArenaPointer() const final {
1284 return MaybeArenaPtr();
1285 }
1286 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1287 return GetDescriptor();
1288 }
1289 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1290 return GetMetadataStatic().descriptor;
1291 }
1292 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1293 return GetMetadataStatic().reflection;
1294 }
1295 static const GraphOpCreation& default_instance();
1296
1297 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1298 static inline const GraphOpCreation* internal_default_instance() {
1299 return reinterpret_cast<const GraphOpCreation*>(
1300 &_GraphOpCreation_default_instance_);
1301 }
1302 static constexpr int kIndexInFileMessages =
1303 5;
1304
1305 friend void swap(GraphOpCreation& a, GraphOpCreation& b) {
1306 a.Swap(&b);
1307 }
1308 inline void Swap(GraphOpCreation* other) {
1309 if (other == this) return;
1310 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1311 InternalSwap(other);
1312 } else {
1313 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1314 }
1315 }
1316 void UnsafeArenaSwap(GraphOpCreation* other) {
1317 if (other == this) return;
1318 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1319 InternalSwap(other);
1320 }
1321
1322 // implements Message ----------------------------------------------
1323
1324 inline GraphOpCreation* New() const final {
1325 return CreateMaybeMessage<GraphOpCreation>(nullptr);
1326 }
1327
1328 GraphOpCreation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1329 return CreateMaybeMessage<GraphOpCreation>(arena);
1330 }
1331 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1332 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1333 void CopyFrom(const GraphOpCreation& from);
1334 void MergeFrom(const GraphOpCreation& from);
1335 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1336 bool IsInitialized() const final;
1337
1338 size_t ByteSizeLong() const final;
1339 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1340 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1341 #else
1342 bool MergePartialFromCodedStream(
1343 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1344 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1345 void SerializeWithCachedSizes(
1346 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1347 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1348 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1349 int GetCachedSize() const final { return _cached_size_.Get(); }
1350
1351 private:
1352 inline void SharedCtor();
1353 inline void SharedDtor();
1354 void SetCachedSize(int size) const final;
1355 void InternalSwap(GraphOpCreation* other);
1356 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1357 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1358 return "tensorflow.GraphOpCreation";
1359 }
1360 protected:
1361 explicit GraphOpCreation(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1362 private:
1363 static void ArenaDtor(void* object);
1364 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1365 private:
1366 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1367 return _internal_metadata_.arena();
1368 }
1369 inline void* MaybeArenaPtr() const {
1370 return _internal_metadata_.raw_arena_ptr();
1371 }
1372 public:
1373
1374 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1375 private:
1376 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1377 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
1378 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
1379 }
1380
1381 public:
1382
1383 // nested types ----------------------------------------------------
1384
1385 // accessors -------------------------------------------------------
1386
1387 enum : int {
1388 kInputNamesFieldNumber = 6,
1389 kOutputTensorIdsFieldNumber = 9,
1390 kOpTypeFieldNumber = 1,
1391 kOpNameFieldNumber = 2,
1392 kGraphNameFieldNumber = 3,
1393 kGraphIdFieldNumber = 4,
1394 kDeviceNameFieldNumber = 5,
1395 kCodeLocationFieldNumber = 8,
1396 kNumOutputsFieldNumber = 7,
1397 };
1398 // repeated string input_names = 6;
1399 int input_names_size() const;
1400 void clear_input_names();
1401 const std::string& input_names(int index) const;
1402 std::string* mutable_input_names(int index);
1403 void set_input_names(int index, const std::string& value);
1404 void set_input_names(int index, std::string&& value);
1405 void set_input_names(int index, const char* value);
1406 void set_input_names(int index, const char* value, size_t size);
1407 std::string* add_input_names();
1408 void add_input_names(const std::string& value);
1409 void add_input_names(std::string&& value);
1410 void add_input_names(const char* value);
1411 void add_input_names(const char* value, size_t size);
1412 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& input_names() const;
1413 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_input_names();
1414
1415 // repeated int32 output_tensor_ids = 9;
1416 int output_tensor_ids_size() const;
1417 void clear_output_tensor_ids();
1418 ::PROTOBUF_NAMESPACE_ID::int32 output_tensor_ids(int index) const;
1419 void set_output_tensor_ids(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
1420 void add_output_tensor_ids(::PROTOBUF_NAMESPACE_ID::int32 value);
1421 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
1422 output_tensor_ids() const;
1423 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
1424 mutable_output_tensor_ids();
1425
1426 // string op_type = 1;
1427 void clear_op_type();
1428 const std::string& op_type() const;
1429 void set_op_type(const std::string& value);
1430 void set_op_type(std::string&& value);
1431 void set_op_type(const char* value);
1432 void set_op_type(const char* value, size_t size);
1433 std::string* mutable_op_type();
1434 std::string* release_op_type();
1435 void set_allocated_op_type(std::string* op_type);
1436 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1437 " string fields are deprecated and will be removed in a"
1438 " future release.")
1439 std::string* unsafe_arena_release_op_type();
1440 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1441 " string fields are deprecated and will be removed in a"
1442 " future release.")
1443 void unsafe_arena_set_allocated_op_type(
1444 std::string* op_type);
1445
1446 // string op_name = 2;
1447 void clear_op_name();
1448 const std::string& op_name() const;
1449 void set_op_name(const std::string& value);
1450 void set_op_name(std::string&& value);
1451 void set_op_name(const char* value);
1452 void set_op_name(const char* value, size_t size);
1453 std::string* mutable_op_name();
1454 std::string* release_op_name();
1455 void set_allocated_op_name(std::string* op_name);
1456 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1457 " string fields are deprecated and will be removed in a"
1458 " future release.")
1459 std::string* unsafe_arena_release_op_name();
1460 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1461 " string fields are deprecated and will be removed in a"
1462 " future release.")
1463 void unsafe_arena_set_allocated_op_name(
1464 std::string* op_name);
1465
1466 // string graph_name = 3;
1467 void clear_graph_name();
1468 const std::string& graph_name() const;
1469 void set_graph_name(const std::string& value);
1470 void set_graph_name(std::string&& value);
1471 void set_graph_name(const char* value);
1472 void set_graph_name(const char* value, size_t size);
1473 std::string* mutable_graph_name();
1474 std::string* release_graph_name();
1475 void set_allocated_graph_name(std::string* graph_name);
1476 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1477 " string fields are deprecated and will be removed in a"
1478 " future release.")
1479 std::string* unsafe_arena_release_graph_name();
1480 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1481 " string fields are deprecated and will be removed in a"
1482 " future release.")
1483 void unsafe_arena_set_allocated_graph_name(
1484 std::string* graph_name);
1485
1486 // string graph_id = 4;
1487 void clear_graph_id();
1488 const std::string& graph_id() const;
1489 void set_graph_id(const std::string& value);
1490 void set_graph_id(std::string&& value);
1491 void set_graph_id(const char* value);
1492 void set_graph_id(const char* value, size_t size);
1493 std::string* mutable_graph_id();
1494 std::string* release_graph_id();
1495 void set_allocated_graph_id(std::string* graph_id);
1496 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1497 " string fields are deprecated and will be removed in a"
1498 " future release.")
1499 std::string* unsafe_arena_release_graph_id();
1500 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1501 " string fields are deprecated and will be removed in a"
1502 " future release.")
1503 void unsafe_arena_set_allocated_graph_id(
1504 std::string* graph_id);
1505
1506 // string device_name = 5;
1507 void clear_device_name();
1508 const std::string& device_name() const;
1509 void set_device_name(const std::string& value);
1510 void set_device_name(std::string&& value);
1511 void set_device_name(const char* value);
1512 void set_device_name(const char* value, size_t size);
1513 std::string* mutable_device_name();
1514 std::string* release_device_name();
1515 void set_allocated_device_name(std::string* device_name);
1516 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1517 " string fields are deprecated and will be removed in a"
1518 " future release.")
1519 std::string* unsafe_arena_release_device_name();
1520 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1521 " string fields are deprecated and will be removed in a"
1522 " future release.")
1523 void unsafe_arena_set_allocated_device_name(
1524 std::string* device_name);
1525
1526 // .tensorflow.CodeLocation code_location = 8;
1527 bool has_code_location() const;
1528 void clear_code_location();
1529 const ::tensorflow::CodeLocation& code_location() const;
1530 ::tensorflow::CodeLocation* release_code_location();
1531 ::tensorflow::CodeLocation* mutable_code_location();
1532 void set_allocated_code_location(::tensorflow::CodeLocation* code_location);
1533 void unsafe_arena_set_allocated_code_location(
1534 ::tensorflow::CodeLocation* code_location);
1535 ::tensorflow::CodeLocation* unsafe_arena_release_code_location();
1536
1537 // int32 num_outputs = 7;
1538 void clear_num_outputs();
1539 ::PROTOBUF_NAMESPACE_ID::int32 num_outputs() const;
1540 void set_num_outputs(::PROTOBUF_NAMESPACE_ID::int32 value);
1541
1542 // @@protoc_insertion_point(class_scope:tensorflow.GraphOpCreation)
1543 private:
1544 class _Internal;
1545
1546 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1547 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1548 typedef void InternalArenaConstructable_;
1549 typedef void DestructorSkippable_;
1550 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> input_names_;
1551 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > output_tensor_ids_;
1552 mutable std::atomic<int> _output_tensor_ids_cached_byte_size_;
1553 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
1554 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
1555 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_name_;
1556 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_id_;
1557 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
1558 ::tensorflow::CodeLocation* code_location_;
1559 ::PROTOBUF_NAMESPACE_ID::int32 num_outputs_;
1560 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1561 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
1562};
1563// -------------------------------------------------------------------
1564
1565class DebuggedGraph :
1566 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DebuggedGraph) */ {
1567 public:
1568 DebuggedGraph();
1569 virtual ~DebuggedGraph();
1570
1571 DebuggedGraph(const DebuggedGraph& from);
1572 DebuggedGraph(DebuggedGraph&& from) noexcept
1573 : DebuggedGraph() {
1574 *this = ::std::move(from);
1575 }
1576
1577 inline DebuggedGraph& operator=(const DebuggedGraph& from) {
1578 CopyFrom(from);
1579 return *this;
1580 }
1581 inline DebuggedGraph& operator=(DebuggedGraph&& from) noexcept {
1582 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1583 if (this != &from) InternalSwap(&from);
1584 } else {
1585 CopyFrom(from);
1586 }
1587 return *this;
1588 }
1589
1590 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1591 return GetArenaNoVirtual();
1592 }
1593 inline void* GetMaybeArenaPointer() const final {
1594 return MaybeArenaPtr();
1595 }
1596 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1597 return GetDescriptor();
1598 }
1599 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1600 return GetMetadataStatic().descriptor;
1601 }
1602 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1603 return GetMetadataStatic().reflection;
1604 }
1605 static const DebuggedGraph& default_instance();
1606
1607 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1608 static inline const DebuggedGraph* internal_default_instance() {
1609 return reinterpret_cast<const DebuggedGraph*>(
1610 &_DebuggedGraph_default_instance_);
1611 }
1612 static constexpr int kIndexInFileMessages =
1613 6;
1614
1615 friend void swap(DebuggedGraph& a, DebuggedGraph& b) {
1616 a.Swap(&b);
1617 }
1618 inline void Swap(DebuggedGraph* other) {
1619 if (other == this) return;
1620 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1621 InternalSwap(other);
1622 } else {
1623 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1624 }
1625 }
1626 void UnsafeArenaSwap(DebuggedGraph* other) {
1627 if (other == this) return;
1628 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1629 InternalSwap(other);
1630 }
1631
1632 // implements Message ----------------------------------------------
1633
1634 inline DebuggedGraph* New() const final {
1635 return CreateMaybeMessage<DebuggedGraph>(nullptr);
1636 }
1637
1638 DebuggedGraph* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1639 return CreateMaybeMessage<DebuggedGraph>(arena);
1640 }
1641 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1642 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1643 void CopyFrom(const DebuggedGraph& from);
1644 void MergeFrom(const DebuggedGraph& from);
1645 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1646 bool IsInitialized() const final;
1647
1648 size_t ByteSizeLong() const final;
1649 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1650 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1651 #else
1652 bool MergePartialFromCodedStream(
1653 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1654 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1655 void SerializeWithCachedSizes(
1656 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1657 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1658 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1659 int GetCachedSize() const final { return _cached_size_.Get(); }
1660
1661 private:
1662 inline void SharedCtor();
1663 inline void SharedDtor();
1664 void SetCachedSize(int size) const final;
1665 void InternalSwap(DebuggedGraph* other);
1666 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1667 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1668 return "tensorflow.DebuggedGraph";
1669 }
1670 protected:
1671 explicit DebuggedGraph(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1672 private:
1673 static void ArenaDtor(void* object);
1674 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1675 private:
1676 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1677 return _internal_metadata_.arena();
1678 }
1679 inline void* MaybeArenaPtr() const {
1680 return _internal_metadata_.raw_arena_ptr();
1681 }
1682 public:
1683
1684 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1685 private:
1686 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1687 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
1688 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
1689 }
1690
1691 public:
1692
1693 // nested types ----------------------------------------------------
1694
1695 // accessors -------------------------------------------------------
1696
1697 enum : int {
1698 kInstrumentedOpsFieldNumber = 3,
1699 kGraphIdFieldNumber = 1,
1700 kGraphNameFieldNumber = 2,
1701 kOriginalGraphDefFieldNumber = 4,
1702 kInstrumentedGraphDefFieldNumber = 5,
1703 kOuterContextIdFieldNumber = 6,
1704 };
1705 // repeated string instrumented_ops = 3;
1706 int instrumented_ops_size() const;
1707 void clear_instrumented_ops();
1708 const std::string& instrumented_ops(int index) const;
1709 std::string* mutable_instrumented_ops(int index);
1710 void set_instrumented_ops(int index, const std::string& value);
1711 void set_instrumented_ops(int index, std::string&& value);
1712 void set_instrumented_ops(int index, const char* value);
1713 void set_instrumented_ops(int index, const char* value, size_t size);
1714 std::string* add_instrumented_ops();
1715 void add_instrumented_ops(const std::string& value);
1716 void add_instrumented_ops(std::string&& value);
1717 void add_instrumented_ops(const char* value);
1718 void add_instrumented_ops(const char* value, size_t size);
1719 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& instrumented_ops() const;
1720 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_instrumented_ops();
1721
1722 // string graph_id = 1;
1723 void clear_graph_id();
1724 const std::string& graph_id() const;
1725 void set_graph_id(const std::string& value);
1726 void set_graph_id(std::string&& value);
1727 void set_graph_id(const char* value);
1728 void set_graph_id(const char* value, size_t size);
1729 std::string* mutable_graph_id();
1730 std::string* release_graph_id();
1731 void set_allocated_graph_id(std::string* graph_id);
1732 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1733 " string fields are deprecated and will be removed in a"
1734 " future release.")
1735 std::string* unsafe_arena_release_graph_id();
1736 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1737 " string fields are deprecated and will be removed in a"
1738 " future release.")
1739 void unsafe_arena_set_allocated_graph_id(
1740 std::string* graph_id);
1741
1742 // string graph_name = 2;
1743 void clear_graph_name();
1744 const std::string& graph_name() const;
1745 void set_graph_name(const std::string& value);
1746 void set_graph_name(std::string&& value);
1747 void set_graph_name(const char* value);
1748 void set_graph_name(const char* value, size_t size);
1749 std::string* mutable_graph_name();
1750 std::string* release_graph_name();
1751 void set_allocated_graph_name(std::string* graph_name);
1752 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1753 " string fields are deprecated and will be removed in a"
1754 " future release.")
1755 std::string* unsafe_arena_release_graph_name();
1756 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1757 " string fields are deprecated and will be removed in a"
1758 " future release.")
1759 void unsafe_arena_set_allocated_graph_name(
1760 std::string* graph_name);
1761
1762 // bytes original_graph_def = 4;
1763 void clear_original_graph_def();
1764 const std::string& original_graph_def() const;
1765 void set_original_graph_def(const std::string& value);
1766 void set_original_graph_def(std::string&& value);
1767 void set_original_graph_def(const char* value);
1768 void set_original_graph_def(const void* value, size_t size);
1769 std::string* mutable_original_graph_def();
1770 std::string* release_original_graph_def();
1771 void set_allocated_original_graph_def(std::string* original_graph_def);
1772 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1773 " string fields are deprecated and will be removed in a"
1774 " future release.")
1775 std::string* unsafe_arena_release_original_graph_def();
1776 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1777 " string fields are deprecated and will be removed in a"
1778 " future release.")
1779 void unsafe_arena_set_allocated_original_graph_def(
1780 std::string* original_graph_def);
1781
1782 // bytes instrumented_graph_def = 5;
1783 void clear_instrumented_graph_def();
1784 const std::string& instrumented_graph_def() const;
1785 void set_instrumented_graph_def(const std::string& value);
1786 void set_instrumented_graph_def(std::string&& value);
1787 void set_instrumented_graph_def(const char* value);
1788 void set_instrumented_graph_def(const void* value, size_t size);
1789 std::string* mutable_instrumented_graph_def();
1790 std::string* release_instrumented_graph_def();
1791 void set_allocated_instrumented_graph_def(std::string* instrumented_graph_def);
1792 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1793 " string fields are deprecated and will be removed in a"
1794 " future release.")
1795 std::string* unsafe_arena_release_instrumented_graph_def();
1796 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1797 " string fields are deprecated and will be removed in a"
1798 " future release.")
1799 void unsafe_arena_set_allocated_instrumented_graph_def(
1800 std::string* instrumented_graph_def);
1801
1802 // string outer_context_id = 6;
1803 void clear_outer_context_id();
1804 const std::string& outer_context_id() const;
1805 void set_outer_context_id(const std::string& value);
1806 void set_outer_context_id(std::string&& value);
1807 void set_outer_context_id(const char* value);
1808 void set_outer_context_id(const char* value, size_t size);
1809 std::string* mutable_outer_context_id();
1810 std::string* release_outer_context_id();
1811 void set_allocated_outer_context_id(std::string* outer_context_id);
1812 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1813 " string fields are deprecated and will be removed in a"
1814 " future release.")
1815 std::string* unsafe_arena_release_outer_context_id();
1816 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1817 " string fields are deprecated and will be removed in a"
1818 " future release.")
1819 void unsafe_arena_set_allocated_outer_context_id(
1820 std::string* outer_context_id);
1821
1822 // @@protoc_insertion_point(class_scope:tensorflow.DebuggedGraph)
1823 private:
1824 class _Internal;
1825
1826 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
1827 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1828 typedef void InternalArenaConstructable_;
1829 typedef void DestructorSkippable_;
1830 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> instrumented_ops_;
1831 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_id_;
1832 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_name_;
1833 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr original_graph_def_;
1834 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr instrumented_graph_def_;
1835 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr outer_context_id_;
1836 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1837 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
1838};
1839// -------------------------------------------------------------------
1840
1841class DebuggedDevice :
1842 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.DebuggedDevice) */ {
1843 public:
1844 DebuggedDevice();
1845 virtual ~DebuggedDevice();
1846
1847 DebuggedDevice(const DebuggedDevice& from);
1848 DebuggedDevice(DebuggedDevice&& from) noexcept
1849 : DebuggedDevice() {
1850 *this = ::std::move(from);
1851 }
1852
1853 inline DebuggedDevice& operator=(const DebuggedDevice& from) {
1854 CopyFrom(from);
1855 return *this;
1856 }
1857 inline DebuggedDevice& operator=(DebuggedDevice&& from) noexcept {
1858 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
1859 if (this != &from) InternalSwap(&from);
1860 } else {
1861 CopyFrom(from);
1862 }
1863 return *this;
1864 }
1865
1866 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
1867 return GetArenaNoVirtual();
1868 }
1869 inline void* GetMaybeArenaPointer() const final {
1870 return MaybeArenaPtr();
1871 }
1872 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
1873 return GetDescriptor();
1874 }
1875 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
1876 return GetMetadataStatic().descriptor;
1877 }
1878 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
1879 return GetMetadataStatic().reflection;
1880 }
1881 static const DebuggedDevice& default_instance();
1882
1883 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
1884 static inline const DebuggedDevice* internal_default_instance() {
1885 return reinterpret_cast<const DebuggedDevice*>(
1886 &_DebuggedDevice_default_instance_);
1887 }
1888 static constexpr int kIndexInFileMessages =
1889 7;
1890
1891 friend void swap(DebuggedDevice& a, DebuggedDevice& b) {
1892 a.Swap(&b);
1893 }
1894 inline void Swap(DebuggedDevice* other) {
1895 if (other == this) return;
1896 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
1897 InternalSwap(other);
1898 } else {
1899 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1900 }
1901 }
1902 void UnsafeArenaSwap(DebuggedDevice* other) {
1903 if (other == this) return;
1904 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
1905 InternalSwap(other);
1906 }
1907
1908 // implements Message ----------------------------------------------
1909
1910 inline DebuggedDevice* New() const final {
1911 return CreateMaybeMessage<DebuggedDevice>(nullptr);
1912 }
1913
1914 DebuggedDevice* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1915 return CreateMaybeMessage<DebuggedDevice>(arena);
1916 }
1917 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1918 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
1919 void CopyFrom(const DebuggedDevice& from);
1920 void MergeFrom(const DebuggedDevice& from);
1921 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1922 bool IsInitialized() const final;
1923
1924 size_t ByteSizeLong() const final;
1925 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1926 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1927 #else
1928 bool MergePartialFromCodedStream(
1929 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
1930 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
1931 void SerializeWithCachedSizes(
1932 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
1933 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
1934 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
1935 int GetCachedSize() const final { return _cached_size_.Get(); }
1936
1937 private:
1938 inline void SharedCtor();
1939 inline void SharedDtor();
1940 void SetCachedSize(int size) const final;
1941 void InternalSwap(DebuggedDevice* other);
1942 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1943 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1944 return "tensorflow.DebuggedDevice";
1945 }
1946 protected:
1947 explicit DebuggedDevice(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1948 private:
1949 static void ArenaDtor(void* object);
1950 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
1951 private:
1952 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
1953 return _internal_metadata_.arena();
1954 }
1955 inline void* MaybeArenaPtr() const {
1956 return _internal_metadata_.raw_arena_ptr();
1957 }
1958 public:
1959
1960 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
1961 private:
1962 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
1963 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
1964 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
1965 }
1966
1967 public:
1968
1969 // nested types ----------------------------------------------------
1970
1971 // accessors -------------------------------------------------------
1972
1973 enum : int {
1974 kDeviceNameFieldNumber = 1,
1975 kDeviceIdFieldNumber = 2,
1976 };
1977 // string device_name = 1;
1978 void clear_device_name();
1979 const std::string& device_name() const;
1980 void set_device_name(const std::string& value);
1981 void set_device_name(std::string&& value);
1982 void set_device_name(const char* value);
1983 void set_device_name(const char* value, size_t size);
1984 std::string* mutable_device_name();
1985 std::string* release_device_name();
1986 void set_allocated_device_name(std::string* device_name);
1987 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1988 " string fields are deprecated and will be removed in a"
1989 " future release.")
1990 std::string* unsafe_arena_release_device_name();
1991 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
1992 " string fields are deprecated and will be removed in a"
1993 " future release.")
1994 void unsafe_arena_set_allocated_device_name(
1995 std::string* device_name);
1996
1997 // int32 device_id = 2;
1998 void clear_device_id();
1999 ::PROTOBUF_NAMESPACE_ID::int32 device_id() const;
2000 void set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value);
2001
2002 // @@protoc_insertion_point(class_scope:tensorflow.DebuggedDevice)
2003 private:
2004 class _Internal;
2005
2006 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2007 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2008 typedef void InternalArenaConstructable_;
2009 typedef void DestructorSkippable_;
2010 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
2011 ::PROTOBUF_NAMESPACE_ID::int32 device_id_;
2012 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2013 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
2014};
2015// -------------------------------------------------------------------
2016
2017class Execution :
2018 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.Execution) */ {
2019 public:
2020 Execution();
2021 virtual ~Execution();
2022
2023 Execution(const Execution& from);
2024 Execution(Execution&& from) noexcept
2025 : Execution() {
2026 *this = ::std::move(from);
2027 }
2028
2029 inline Execution& operator=(const Execution& from) {
2030 CopyFrom(from);
2031 return *this;
2032 }
2033 inline Execution& operator=(Execution&& from) noexcept {
2034 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2035 if (this != &from) InternalSwap(&from);
2036 } else {
2037 CopyFrom(from);
2038 }
2039 return *this;
2040 }
2041
2042 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
2043 return GetArenaNoVirtual();
2044 }
2045 inline void* GetMaybeArenaPointer() const final {
2046 return MaybeArenaPtr();
2047 }
2048 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2049 return GetDescriptor();
2050 }
2051 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2052 return GetMetadataStatic().descriptor;
2053 }
2054 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2055 return GetMetadataStatic().reflection;
2056 }
2057 static const Execution& default_instance();
2058
2059 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2060 static inline const Execution* internal_default_instance() {
2061 return reinterpret_cast<const Execution*>(
2062 &_Execution_default_instance_);
2063 }
2064 static constexpr int kIndexInFileMessages =
2065 8;
2066
2067 friend void swap(Execution& a, Execution& b) {
2068 a.Swap(&b);
2069 }
2070 inline void Swap(Execution* other) {
2071 if (other == this) return;
2072 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2073 InternalSwap(other);
2074 } else {
2075 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2076 }
2077 }
2078 void UnsafeArenaSwap(Execution* other) {
2079 if (other == this) return;
2080 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2081 InternalSwap(other);
2082 }
2083
2084 // implements Message ----------------------------------------------
2085
2086 inline Execution* New() const final {
2087 return CreateMaybeMessage<Execution>(nullptr);
2088 }
2089
2090 Execution* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2091 return CreateMaybeMessage<Execution>(arena);
2092 }
2093 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2094 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2095 void CopyFrom(const Execution& from);
2096 void MergeFrom(const Execution& from);
2097 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2098 bool IsInitialized() const final;
2099
2100 size_t ByteSizeLong() const final;
2101 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2102 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2103 #else
2104 bool MergePartialFromCodedStream(
2105 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2106 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2107 void SerializeWithCachedSizes(
2108 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2109 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2110 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2111 int GetCachedSize() const final { return _cached_size_.Get(); }
2112
2113 private:
2114 inline void SharedCtor();
2115 inline void SharedDtor();
2116 void SetCachedSize(int size) const final;
2117 void InternalSwap(Execution* other);
2118 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2119 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2120 return "tensorflow.Execution";
2121 }
2122 protected:
2123 explicit Execution(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2124 private:
2125 static void ArenaDtor(void* object);
2126 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2127 private:
2128 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2129 return _internal_metadata_.arena();
2130 }
2131 inline void* MaybeArenaPtr() const {
2132 return _internal_metadata_.raw_arena_ptr();
2133 }
2134 public:
2135
2136 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2137 private:
2138 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2139 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
2140 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
2141 }
2142
2143 public:
2144
2145 // nested types ----------------------------------------------------
2146
2147 // accessors -------------------------------------------------------
2148
2149 enum : int {
2150 kInputTensorIdsFieldNumber = 4,
2151 kOutputTensorIdsFieldNumber = 5,
2152 kTensorProtosFieldNumber = 7,
2153 kOutputTensorDeviceIdsFieldNumber = 9,
2154 kOpTypeFieldNumber = 1,
2155 kGraphIdFieldNumber = 3,
2156 kCodeLocationFieldNumber = 8,
2157 kNumOutputsFieldNumber = 2,
2158 kTensorDebugModeFieldNumber = 6,
2159 };
2160 // repeated int64 input_tensor_ids = 4;
2161 int input_tensor_ids_size() const;
2162 void clear_input_tensor_ids();
2163 ::PROTOBUF_NAMESPACE_ID::int64 input_tensor_ids(int index) const;
2164 void set_input_tensor_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
2165 void add_input_tensor_ids(::PROTOBUF_NAMESPACE_ID::int64 value);
2166 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
2167 input_tensor_ids() const;
2168 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
2169 mutable_input_tensor_ids();
2170
2171 // repeated int64 output_tensor_ids = 5;
2172 int output_tensor_ids_size() const;
2173 void clear_output_tensor_ids();
2174 ::PROTOBUF_NAMESPACE_ID::int64 output_tensor_ids(int index) const;
2175 void set_output_tensor_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
2176 void add_output_tensor_ids(::PROTOBUF_NAMESPACE_ID::int64 value);
2177 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
2178 output_tensor_ids() const;
2179 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
2180 mutable_output_tensor_ids();
2181
2182 // repeated .tensorflow.TensorProto tensor_protos = 7;
2183 int tensor_protos_size() const;
2184 void clear_tensor_protos();
2185 ::tensorflow::TensorProto* mutable_tensor_protos(int index);
2186 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
2187 mutable_tensor_protos();
2188 const ::tensorflow::TensorProto& tensor_protos(int index) const;
2189 ::tensorflow::TensorProto* add_tensor_protos();
2190 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
2191 tensor_protos() const;
2192
2193 // repeated int32 output_tensor_device_ids = 9;
2194 int output_tensor_device_ids_size() const;
2195 void clear_output_tensor_device_ids();
2196 ::PROTOBUF_NAMESPACE_ID::int32 output_tensor_device_ids(int index) const;
2197 void set_output_tensor_device_ids(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
2198 void add_output_tensor_device_ids(::PROTOBUF_NAMESPACE_ID::int32 value);
2199 const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
2200 output_tensor_device_ids() const;
2201 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
2202 mutable_output_tensor_device_ids();
2203
2204 // string op_type = 1;
2205 void clear_op_type();
2206 const std::string& op_type() const;
2207 void set_op_type(const std::string& value);
2208 void set_op_type(std::string&& value);
2209 void set_op_type(const char* value);
2210 void set_op_type(const char* value, size_t size);
2211 std::string* mutable_op_type();
2212 std::string* release_op_type();
2213 void set_allocated_op_type(std::string* op_type);
2214 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2215 " string fields are deprecated and will be removed in a"
2216 " future release.")
2217 std::string* unsafe_arena_release_op_type();
2218 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2219 " string fields are deprecated and will be removed in a"
2220 " future release.")
2221 void unsafe_arena_set_allocated_op_type(
2222 std::string* op_type);
2223
2224 // string graph_id = 3;
2225 void clear_graph_id();
2226 const std::string& graph_id() const;
2227 void set_graph_id(const std::string& value);
2228 void set_graph_id(std::string&& value);
2229 void set_graph_id(const char* value);
2230 void set_graph_id(const char* value, size_t size);
2231 std::string* mutable_graph_id();
2232 std::string* release_graph_id();
2233 void set_allocated_graph_id(std::string* graph_id);
2234 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2235 " string fields are deprecated and will be removed in a"
2236 " future release.")
2237 std::string* unsafe_arena_release_graph_id();
2238 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2239 " string fields are deprecated and will be removed in a"
2240 " future release.")
2241 void unsafe_arena_set_allocated_graph_id(
2242 std::string* graph_id);
2243
2244 // .tensorflow.CodeLocation code_location = 8;
2245 bool has_code_location() const;
2246 void clear_code_location();
2247 const ::tensorflow::CodeLocation& code_location() const;
2248 ::tensorflow::CodeLocation* release_code_location();
2249 ::tensorflow::CodeLocation* mutable_code_location();
2250 void set_allocated_code_location(::tensorflow::CodeLocation* code_location);
2251 void unsafe_arena_set_allocated_code_location(
2252 ::tensorflow::CodeLocation* code_location);
2253 ::tensorflow::CodeLocation* unsafe_arena_release_code_location();
2254
2255 // int32 num_outputs = 2;
2256 void clear_num_outputs();
2257 ::PROTOBUF_NAMESPACE_ID::int32 num_outputs() const;
2258 void set_num_outputs(::PROTOBUF_NAMESPACE_ID::int32 value);
2259
2260 // .tensorflow.TensorDebugMode tensor_debug_mode = 6;
2261 void clear_tensor_debug_mode();
2262 ::tensorflow::TensorDebugMode tensor_debug_mode() const;
2263 void set_tensor_debug_mode(::tensorflow::TensorDebugMode value);
2264
2265 // @@protoc_insertion_point(class_scope:tensorflow.Execution)
2266 private:
2267 class _Internal;
2268
2269 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2270 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2271 typedef void InternalArenaConstructable_;
2272 typedef void DestructorSkippable_;
2273 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > input_tensor_ids_;
2274 mutable std::atomic<int> _input_tensor_ids_cached_byte_size_;
2275 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > output_tensor_ids_;
2276 mutable std::atomic<int> _output_tensor_ids_cached_byte_size_;
2277 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto > tensor_protos_;
2278 ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > output_tensor_device_ids_;
2279 mutable std::atomic<int> _output_tensor_device_ids_cached_byte_size_;
2280 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_type_;
2281 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr graph_id_;
2282 ::tensorflow::CodeLocation* code_location_;
2283 ::PROTOBUF_NAMESPACE_ID::int32 num_outputs_;
2284 int tensor_debug_mode_;
2285 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2286 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
2287};
2288// -------------------------------------------------------------------
2289
2290class GraphExecutionTrace :
2291 public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:tensorflow.GraphExecutionTrace) */ {
2292 public:
2293 GraphExecutionTrace();
2294 virtual ~GraphExecutionTrace();
2295
2296 GraphExecutionTrace(const GraphExecutionTrace& from);
2297 GraphExecutionTrace(GraphExecutionTrace&& from) noexcept
2298 : GraphExecutionTrace() {
2299 *this = ::std::move(from);
2300 }
2301
2302 inline GraphExecutionTrace& operator=(const GraphExecutionTrace& from) {
2303 CopyFrom(from);
2304 return *this;
2305 }
2306 inline GraphExecutionTrace& operator=(GraphExecutionTrace&& from) noexcept {
2307 if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
2308 if (this != &from) InternalSwap(&from);
2309 } else {
2310 CopyFrom(from);
2311 }
2312 return *this;
2313 }
2314
2315 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArena() const final {
2316 return GetArenaNoVirtual();
2317 }
2318 inline void* GetMaybeArenaPointer() const final {
2319 return MaybeArenaPtr();
2320 }
2321 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
2322 return GetDescriptor();
2323 }
2324 static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
2325 return GetMetadataStatic().descriptor;
2326 }
2327 static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
2328 return GetMetadataStatic().reflection;
2329 }
2330 static const GraphExecutionTrace& default_instance();
2331
2332 static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY
2333 static inline const GraphExecutionTrace* internal_default_instance() {
2334 return reinterpret_cast<const GraphExecutionTrace*>(
2335 &_GraphExecutionTrace_default_instance_);
2336 }
2337 static constexpr int kIndexInFileMessages =
2338 9;
2339
2340 friend void swap(GraphExecutionTrace& a, GraphExecutionTrace& b) {
2341 a.Swap(&b);
2342 }
2343 inline void Swap(GraphExecutionTrace* other) {
2344 if (other == this) return;
2345 if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
2346 InternalSwap(other);
2347 } else {
2348 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
2349 }
2350 }
2351 void UnsafeArenaSwap(GraphExecutionTrace* other) {
2352 if (other == this) return;
2353 GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
2354 InternalSwap(other);
2355 }
2356
2357 // implements Message ----------------------------------------------
2358
2359 inline GraphExecutionTrace* New() const final {
2360 return CreateMaybeMessage<GraphExecutionTrace>(nullptr);
2361 }
2362
2363 GraphExecutionTrace* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
2364 return CreateMaybeMessage<GraphExecutionTrace>(arena);
2365 }
2366 void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2367 void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
2368 void CopyFrom(const GraphExecutionTrace& from);
2369 void MergeFrom(const GraphExecutionTrace& from);
2370 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
2371 bool IsInitialized() const final;
2372
2373 size_t ByteSizeLong() const final;
2374 #if GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2375 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
2376 #else
2377 bool MergePartialFromCodedStream(
2378 ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) final;
2379 #endif // GOOGLE_PROTOBUF_ENABLE_EXPERIMENTAL_PARSER
2380 void SerializeWithCachedSizes(
2381 ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const final;
2382 ::PROTOBUF_NAMESPACE_ID::uint8* InternalSerializeWithCachedSizesToArray(
2383 ::PROTOBUF_NAMESPACE_ID::uint8* target) const final;
2384 int GetCachedSize() const final { return _cached_size_.Get(); }
2385
2386 private:
2387 inline void SharedCtor();
2388 inline void SharedDtor();
2389 void SetCachedSize(int size) const final;
2390 void InternalSwap(GraphExecutionTrace* other);
2391 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
2392 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
2393 return "tensorflow.GraphExecutionTrace";
2394 }
2395 protected:
2396 explicit GraphExecutionTrace(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2397 private:
2398 static void ArenaDtor(void* object);
2399 inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
2400 private:
2401 inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
2402 return _internal_metadata_.arena();
2403 }
2404 inline void* MaybeArenaPtr() const {
2405 return _internal_metadata_.raw_arena_ptr();
2406 }
2407 public:
2408
2409 ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
2410 private:
2411 static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
2412 ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto);
2413 return ::descriptor_table_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto.file_level_metadata[kIndexInFileMessages];
2414 }
2415
2416 public:
2417
2418 // nested types ----------------------------------------------------
2419
2420 // accessors -------------------------------------------------------
2421
2422 enum : int {
2423 kTfdbgContextIdFieldNumber = 1,
2424 kOpNameFieldNumber = 2,
2425 kDeviceNameFieldNumber = 6,
2426 kTensorProtoFieldNumber = 5,
2427 kOutputSlotFieldNumber = 3,
2428 kTensorDebugModeFieldNumber = 4,
2429 };
2430 // string tfdbg_context_id = 1;
2431 void clear_tfdbg_context_id();
2432 const std::string& tfdbg_context_id() const;
2433 void set_tfdbg_context_id(const std::string& value);
2434 void set_tfdbg_context_id(std::string&& value);
2435 void set_tfdbg_context_id(const char* value);
2436 void set_tfdbg_context_id(const char* value, size_t size);
2437 std::string* mutable_tfdbg_context_id();
2438 std::string* release_tfdbg_context_id();
2439 void set_allocated_tfdbg_context_id(std::string* tfdbg_context_id);
2440 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2441 " string fields are deprecated and will be removed in a"
2442 " future release.")
2443 std::string* unsafe_arena_release_tfdbg_context_id();
2444 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2445 " string fields are deprecated and will be removed in a"
2446 " future release.")
2447 void unsafe_arena_set_allocated_tfdbg_context_id(
2448 std::string* tfdbg_context_id);
2449
2450 // string op_name = 2;
2451 void clear_op_name();
2452 const std::string& op_name() const;
2453 void set_op_name(const std::string& value);
2454 void set_op_name(std::string&& value);
2455 void set_op_name(const char* value);
2456 void set_op_name(const char* value, size_t size);
2457 std::string* mutable_op_name();
2458 std::string* release_op_name();
2459 void set_allocated_op_name(std::string* op_name);
2460 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2461 " string fields are deprecated and will be removed in a"
2462 " future release.")
2463 std::string* unsafe_arena_release_op_name();
2464 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2465 " string fields are deprecated and will be removed in a"
2466 " future release.")
2467 void unsafe_arena_set_allocated_op_name(
2468 std::string* op_name);
2469
2470 // string device_name = 6;
2471 void clear_device_name();
2472 const std::string& device_name() const;
2473 void set_device_name(const std::string& value);
2474 void set_device_name(std::string&& value);
2475 void set_device_name(const char* value);
2476 void set_device_name(const char* value, size_t size);
2477 std::string* mutable_device_name();
2478 std::string* release_device_name();
2479 void set_allocated_device_name(std::string* device_name);
2480 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2481 " string fields are deprecated and will be removed in a"
2482 " future release.")
2483 std::string* unsafe_arena_release_device_name();
2484 GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
2485 " string fields are deprecated and will be removed in a"
2486 " future release.")
2487 void unsafe_arena_set_allocated_device_name(
2488 std::string* device_name);
2489
2490 // .tensorflow.TensorProto tensor_proto = 5;
2491 bool has_tensor_proto() const;
2492 void clear_tensor_proto();
2493 const ::tensorflow::TensorProto& tensor_proto() const;
2494 ::tensorflow::TensorProto* release_tensor_proto();
2495 ::tensorflow::TensorProto* mutable_tensor_proto();
2496 void set_allocated_tensor_proto(::tensorflow::TensorProto* tensor_proto);
2497 void unsafe_arena_set_allocated_tensor_proto(
2498 ::tensorflow::TensorProto* tensor_proto);
2499 ::tensorflow::TensorProto* unsafe_arena_release_tensor_proto();
2500
2501 // int32 output_slot = 3;
2502 void clear_output_slot();
2503 ::PROTOBUF_NAMESPACE_ID::int32 output_slot() const;
2504 void set_output_slot(::PROTOBUF_NAMESPACE_ID::int32 value);
2505
2506 // .tensorflow.TensorDebugMode tensor_debug_mode = 4;
2507 void clear_tensor_debug_mode();
2508 ::tensorflow::TensorDebugMode tensor_debug_mode() const;
2509 void set_tensor_debug_mode(::tensorflow::TensorDebugMode value);
2510
2511 // @@protoc_insertion_point(class_scope:tensorflow.GraphExecutionTrace)
2512 private:
2513 class _Internal;
2514
2515 ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
2516 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2517 typedef void InternalArenaConstructable_;
2518 typedef void DestructorSkippable_;
2519 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr tfdbg_context_id_;
2520 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr op_name_;
2521 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
2522 ::tensorflow::TensorProto* tensor_proto_;
2523 ::PROTOBUF_NAMESPACE_ID::int32 output_slot_;
2524 int tensor_debug_mode_;
2525 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2526 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto;
2527};
2528// ===================================================================
2529
2530
2531// ===================================================================
2532
2533#ifdef __GNUC__
2534 #pragma GCC diagnostic push
2535 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2536#endif // __GNUC__
2537// DebugEvent
2538
2539// double wall_time = 1;
2540inline void DebugEvent::clear_wall_time() {
2541 wall_time_ = 0;
2542}
2543inline double DebugEvent::wall_time() const {
2544 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.wall_time)
2545 return wall_time_;
2546}
2547inline void DebugEvent::set_wall_time(double value) {
2548
2549 wall_time_ = value;
2550 // @@protoc_insertion_point(field_set:tensorflow.DebugEvent.wall_time)
2551}
2552
2553// int64 step = 2;
2554inline void DebugEvent::clear_step() {
2555 step_ = PROTOBUF_LONGLONG(0);
2556}
2557inline ::PROTOBUF_NAMESPACE_ID::int64 DebugEvent::step() const {
2558 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.step)
2559 return step_;
2560}
2561inline void DebugEvent::set_step(::PROTOBUF_NAMESPACE_ID::int64 value) {
2562
2563 step_ = value;
2564 // @@protoc_insertion_point(field_set:tensorflow.DebugEvent.step)
2565}
2566
2567// .tensorflow.DebugMetadata debug_metadata = 3;
2568inline bool DebugEvent::has_debug_metadata() const {
2569 return what_case() == kDebugMetadata;
2570}
2571inline void DebugEvent::set_has_debug_metadata() {
2572 _oneof_case_[0] = kDebugMetadata;
2573}
2574inline void DebugEvent::clear_debug_metadata() {
2575 if (has_debug_metadata()) {
2576 if (GetArenaNoVirtual() == nullptr) {
2577 delete what_.debug_metadata_;
2578 }
2579 clear_has_what();
2580 }
2581}
2582inline ::tensorflow::DebugMetadata* DebugEvent::release_debug_metadata() {
2583 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.debug_metadata)
2584 if (has_debug_metadata()) {
2585 clear_has_what();
2586 ::tensorflow::DebugMetadata* temp = what_.debug_metadata_;
2587 if (GetArenaNoVirtual() != nullptr) {
2588 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2589 }
2590 what_.debug_metadata_ = nullptr;
2591 return temp;
2592 } else {
2593 return nullptr;
2594 }
2595}
2596inline const ::tensorflow::DebugMetadata& DebugEvent::debug_metadata() const {
2597 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.debug_metadata)
2598 return has_debug_metadata()
2599 ? *what_.debug_metadata_
2600 : *reinterpret_cast< ::tensorflow::DebugMetadata*>(&::tensorflow::_DebugMetadata_default_instance_);
2601}
2602inline ::tensorflow::DebugMetadata* DebugEvent::unsafe_arena_release_debug_metadata() {
2603 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.debug_metadata)
2604 if (has_debug_metadata()) {
2605 clear_has_what();
2606 ::tensorflow::DebugMetadata* temp = what_.debug_metadata_;
2607 what_.debug_metadata_ = nullptr;
2608 return temp;
2609 } else {
2610 return nullptr;
2611 }
2612}
2613inline void DebugEvent::unsafe_arena_set_allocated_debug_metadata(::tensorflow::DebugMetadata* debug_metadata) {
2614 clear_what();
2615 if (debug_metadata) {
2616 set_has_debug_metadata();
2617 what_.debug_metadata_ = debug_metadata;
2618 }
2619 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.debug_metadata)
2620}
2621inline ::tensorflow::DebugMetadata* DebugEvent::mutable_debug_metadata() {
2622 if (!has_debug_metadata()) {
2623 clear_what();
2624 set_has_debug_metadata();
2625 what_.debug_metadata_ = CreateMaybeMessage< ::tensorflow::DebugMetadata >(
2626 GetArenaNoVirtual());
2627 }
2628 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.debug_metadata)
2629 return what_.debug_metadata_;
2630}
2631
2632// .tensorflow.SourceFile source_file = 4;
2633inline bool DebugEvent::has_source_file() const {
2634 return what_case() == kSourceFile;
2635}
2636inline void DebugEvent::set_has_source_file() {
2637 _oneof_case_[0] = kSourceFile;
2638}
2639inline void DebugEvent::clear_source_file() {
2640 if (has_source_file()) {
2641 if (GetArenaNoVirtual() == nullptr) {
2642 delete what_.source_file_;
2643 }
2644 clear_has_what();
2645 }
2646}
2647inline ::tensorflow::SourceFile* DebugEvent::release_source_file() {
2648 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.source_file)
2649 if (has_source_file()) {
2650 clear_has_what();
2651 ::tensorflow::SourceFile* temp = what_.source_file_;
2652 if (GetArenaNoVirtual() != nullptr) {
2653 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2654 }
2655 what_.source_file_ = nullptr;
2656 return temp;
2657 } else {
2658 return nullptr;
2659 }
2660}
2661inline const ::tensorflow::SourceFile& DebugEvent::source_file() const {
2662 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.source_file)
2663 return has_source_file()
2664 ? *what_.source_file_
2665 : *reinterpret_cast< ::tensorflow::SourceFile*>(&::tensorflow::_SourceFile_default_instance_);
2666}
2667inline ::tensorflow::SourceFile* DebugEvent::unsafe_arena_release_source_file() {
2668 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.source_file)
2669 if (has_source_file()) {
2670 clear_has_what();
2671 ::tensorflow::SourceFile* temp = what_.source_file_;
2672 what_.source_file_ = nullptr;
2673 return temp;
2674 } else {
2675 return nullptr;
2676 }
2677}
2678inline void DebugEvent::unsafe_arena_set_allocated_source_file(::tensorflow::SourceFile* source_file) {
2679 clear_what();
2680 if (source_file) {
2681 set_has_source_file();
2682 what_.source_file_ = source_file;
2683 }
2684 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.source_file)
2685}
2686inline ::tensorflow::SourceFile* DebugEvent::mutable_source_file() {
2687 if (!has_source_file()) {
2688 clear_what();
2689 set_has_source_file();
2690 what_.source_file_ = CreateMaybeMessage< ::tensorflow::SourceFile >(
2691 GetArenaNoVirtual());
2692 }
2693 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.source_file)
2694 return what_.source_file_;
2695}
2696
2697// .tensorflow.StackFrameWithId stack_frame_with_id = 6;
2698inline bool DebugEvent::has_stack_frame_with_id() const {
2699 return what_case() == kStackFrameWithId;
2700}
2701inline void DebugEvent::set_has_stack_frame_with_id() {
2702 _oneof_case_[0] = kStackFrameWithId;
2703}
2704inline void DebugEvent::clear_stack_frame_with_id() {
2705 if (has_stack_frame_with_id()) {
2706 if (GetArenaNoVirtual() == nullptr) {
2707 delete what_.stack_frame_with_id_;
2708 }
2709 clear_has_what();
2710 }
2711}
2712inline ::tensorflow::StackFrameWithId* DebugEvent::release_stack_frame_with_id() {
2713 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.stack_frame_with_id)
2714 if (has_stack_frame_with_id()) {
2715 clear_has_what();
2716 ::tensorflow::StackFrameWithId* temp = what_.stack_frame_with_id_;
2717 if (GetArenaNoVirtual() != nullptr) {
2718 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2719 }
2720 what_.stack_frame_with_id_ = nullptr;
2721 return temp;
2722 } else {
2723 return nullptr;
2724 }
2725}
2726inline const ::tensorflow::StackFrameWithId& DebugEvent::stack_frame_with_id() const {
2727 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.stack_frame_with_id)
2728 return has_stack_frame_with_id()
2729 ? *what_.stack_frame_with_id_
2730 : *reinterpret_cast< ::tensorflow::StackFrameWithId*>(&::tensorflow::_StackFrameWithId_default_instance_);
2731}
2732inline ::tensorflow::StackFrameWithId* DebugEvent::unsafe_arena_release_stack_frame_with_id() {
2733 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.stack_frame_with_id)
2734 if (has_stack_frame_with_id()) {
2735 clear_has_what();
2736 ::tensorflow::StackFrameWithId* temp = what_.stack_frame_with_id_;
2737 what_.stack_frame_with_id_ = nullptr;
2738 return temp;
2739 } else {
2740 return nullptr;
2741 }
2742}
2743inline void DebugEvent::unsafe_arena_set_allocated_stack_frame_with_id(::tensorflow::StackFrameWithId* stack_frame_with_id) {
2744 clear_what();
2745 if (stack_frame_with_id) {
2746 set_has_stack_frame_with_id();
2747 what_.stack_frame_with_id_ = stack_frame_with_id;
2748 }
2749 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.stack_frame_with_id)
2750}
2751inline ::tensorflow::StackFrameWithId* DebugEvent::mutable_stack_frame_with_id() {
2752 if (!has_stack_frame_with_id()) {
2753 clear_what();
2754 set_has_stack_frame_with_id();
2755 what_.stack_frame_with_id_ = CreateMaybeMessage< ::tensorflow::StackFrameWithId >(
2756 GetArenaNoVirtual());
2757 }
2758 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.stack_frame_with_id)
2759 return what_.stack_frame_with_id_;
2760}
2761
2762// .tensorflow.GraphOpCreation graph_op_creation = 7;
2763inline bool DebugEvent::has_graph_op_creation() const {
2764 return what_case() == kGraphOpCreation;
2765}
2766inline void DebugEvent::set_has_graph_op_creation() {
2767 _oneof_case_[0] = kGraphOpCreation;
2768}
2769inline void DebugEvent::clear_graph_op_creation() {
2770 if (has_graph_op_creation()) {
2771 if (GetArenaNoVirtual() == nullptr) {
2772 delete what_.graph_op_creation_;
2773 }
2774 clear_has_what();
2775 }
2776}
2777inline ::tensorflow::GraphOpCreation* DebugEvent::release_graph_op_creation() {
2778 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.graph_op_creation)
2779 if (has_graph_op_creation()) {
2780 clear_has_what();
2781 ::tensorflow::GraphOpCreation* temp = what_.graph_op_creation_;
2782 if (GetArenaNoVirtual() != nullptr) {
2783 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2784 }
2785 what_.graph_op_creation_ = nullptr;
2786 return temp;
2787 } else {
2788 return nullptr;
2789 }
2790}
2791inline const ::tensorflow::GraphOpCreation& DebugEvent::graph_op_creation() const {
2792 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.graph_op_creation)
2793 return has_graph_op_creation()
2794 ? *what_.graph_op_creation_
2795 : *reinterpret_cast< ::tensorflow::GraphOpCreation*>(&::tensorflow::_GraphOpCreation_default_instance_);
2796}
2797inline ::tensorflow::GraphOpCreation* DebugEvent::unsafe_arena_release_graph_op_creation() {
2798 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.graph_op_creation)
2799 if (has_graph_op_creation()) {
2800 clear_has_what();
2801 ::tensorflow::GraphOpCreation* temp = what_.graph_op_creation_;
2802 what_.graph_op_creation_ = nullptr;
2803 return temp;
2804 } else {
2805 return nullptr;
2806 }
2807}
2808inline void DebugEvent::unsafe_arena_set_allocated_graph_op_creation(::tensorflow::GraphOpCreation* graph_op_creation) {
2809 clear_what();
2810 if (graph_op_creation) {
2811 set_has_graph_op_creation();
2812 what_.graph_op_creation_ = graph_op_creation;
2813 }
2814 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.graph_op_creation)
2815}
2816inline ::tensorflow::GraphOpCreation* DebugEvent::mutable_graph_op_creation() {
2817 if (!has_graph_op_creation()) {
2818 clear_what();
2819 set_has_graph_op_creation();
2820 what_.graph_op_creation_ = CreateMaybeMessage< ::tensorflow::GraphOpCreation >(
2821 GetArenaNoVirtual());
2822 }
2823 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.graph_op_creation)
2824 return what_.graph_op_creation_;
2825}
2826
2827// .tensorflow.DebuggedGraph debugged_graph = 8;
2828inline bool DebugEvent::has_debugged_graph() const {
2829 return what_case() == kDebuggedGraph;
2830}
2831inline void DebugEvent::set_has_debugged_graph() {
2832 _oneof_case_[0] = kDebuggedGraph;
2833}
2834inline void DebugEvent::clear_debugged_graph() {
2835 if (has_debugged_graph()) {
2836 if (GetArenaNoVirtual() == nullptr) {
2837 delete what_.debugged_graph_;
2838 }
2839 clear_has_what();
2840 }
2841}
2842inline ::tensorflow::DebuggedGraph* DebugEvent::release_debugged_graph() {
2843 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.debugged_graph)
2844 if (has_debugged_graph()) {
2845 clear_has_what();
2846 ::tensorflow::DebuggedGraph* temp = what_.debugged_graph_;
2847 if (GetArenaNoVirtual() != nullptr) {
2848 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2849 }
2850 what_.debugged_graph_ = nullptr;
2851 return temp;
2852 } else {
2853 return nullptr;
2854 }
2855}
2856inline const ::tensorflow::DebuggedGraph& DebugEvent::debugged_graph() const {
2857 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.debugged_graph)
2858 return has_debugged_graph()
2859 ? *what_.debugged_graph_
2860 : *reinterpret_cast< ::tensorflow::DebuggedGraph*>(&::tensorflow::_DebuggedGraph_default_instance_);
2861}
2862inline ::tensorflow::DebuggedGraph* DebugEvent::unsafe_arena_release_debugged_graph() {
2863 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.debugged_graph)
2864 if (has_debugged_graph()) {
2865 clear_has_what();
2866 ::tensorflow::DebuggedGraph* temp = what_.debugged_graph_;
2867 what_.debugged_graph_ = nullptr;
2868 return temp;
2869 } else {
2870 return nullptr;
2871 }
2872}
2873inline void DebugEvent::unsafe_arena_set_allocated_debugged_graph(::tensorflow::DebuggedGraph* debugged_graph) {
2874 clear_what();
2875 if (debugged_graph) {
2876 set_has_debugged_graph();
2877 what_.debugged_graph_ = debugged_graph;
2878 }
2879 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.debugged_graph)
2880}
2881inline ::tensorflow::DebuggedGraph* DebugEvent::mutable_debugged_graph() {
2882 if (!has_debugged_graph()) {
2883 clear_what();
2884 set_has_debugged_graph();
2885 what_.debugged_graph_ = CreateMaybeMessage< ::tensorflow::DebuggedGraph >(
2886 GetArenaNoVirtual());
2887 }
2888 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.debugged_graph)
2889 return what_.debugged_graph_;
2890}
2891
2892// .tensorflow.Execution execution = 9;
2893inline bool DebugEvent::has_execution() const {
2894 return what_case() == kExecution;
2895}
2896inline void DebugEvent::set_has_execution() {
2897 _oneof_case_[0] = kExecution;
2898}
2899inline void DebugEvent::clear_execution() {
2900 if (has_execution()) {
2901 if (GetArenaNoVirtual() == nullptr) {
2902 delete what_.execution_;
2903 }
2904 clear_has_what();
2905 }
2906}
2907inline ::tensorflow::Execution* DebugEvent::release_execution() {
2908 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.execution)
2909 if (has_execution()) {
2910 clear_has_what();
2911 ::tensorflow::Execution* temp = what_.execution_;
2912 if (GetArenaNoVirtual() != nullptr) {
2913 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2914 }
2915 what_.execution_ = nullptr;
2916 return temp;
2917 } else {
2918 return nullptr;
2919 }
2920}
2921inline const ::tensorflow::Execution& DebugEvent::execution() const {
2922 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.execution)
2923 return has_execution()
2924 ? *what_.execution_
2925 : *reinterpret_cast< ::tensorflow::Execution*>(&::tensorflow::_Execution_default_instance_);
2926}
2927inline ::tensorflow::Execution* DebugEvent::unsafe_arena_release_execution() {
2928 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.execution)
2929 if (has_execution()) {
2930 clear_has_what();
2931 ::tensorflow::Execution* temp = what_.execution_;
2932 what_.execution_ = nullptr;
2933 return temp;
2934 } else {
2935 return nullptr;
2936 }
2937}
2938inline void DebugEvent::unsafe_arena_set_allocated_execution(::tensorflow::Execution* execution) {
2939 clear_what();
2940 if (execution) {
2941 set_has_execution();
2942 what_.execution_ = execution;
2943 }
2944 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.execution)
2945}
2946inline ::tensorflow::Execution* DebugEvent::mutable_execution() {
2947 if (!has_execution()) {
2948 clear_what();
2949 set_has_execution();
2950 what_.execution_ = CreateMaybeMessage< ::tensorflow::Execution >(
2951 GetArenaNoVirtual());
2952 }
2953 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.execution)
2954 return what_.execution_;
2955}
2956
2957// .tensorflow.GraphExecutionTrace graph_execution_trace = 10;
2958inline bool DebugEvent::has_graph_execution_trace() const {
2959 return what_case() == kGraphExecutionTrace;
2960}
2961inline void DebugEvent::set_has_graph_execution_trace() {
2962 _oneof_case_[0] = kGraphExecutionTrace;
2963}
2964inline void DebugEvent::clear_graph_execution_trace() {
2965 if (has_graph_execution_trace()) {
2966 if (GetArenaNoVirtual() == nullptr) {
2967 delete what_.graph_execution_trace_;
2968 }
2969 clear_has_what();
2970 }
2971}
2972inline ::tensorflow::GraphExecutionTrace* DebugEvent::release_graph_execution_trace() {
2973 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.graph_execution_trace)
2974 if (has_graph_execution_trace()) {
2975 clear_has_what();
2976 ::tensorflow::GraphExecutionTrace* temp = what_.graph_execution_trace_;
2977 if (GetArenaNoVirtual() != nullptr) {
2978 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2979 }
2980 what_.graph_execution_trace_ = nullptr;
2981 return temp;
2982 } else {
2983 return nullptr;
2984 }
2985}
2986inline const ::tensorflow::GraphExecutionTrace& DebugEvent::graph_execution_trace() const {
2987 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.graph_execution_trace)
2988 return has_graph_execution_trace()
2989 ? *what_.graph_execution_trace_
2990 : *reinterpret_cast< ::tensorflow::GraphExecutionTrace*>(&::tensorflow::_GraphExecutionTrace_default_instance_);
2991}
2992inline ::tensorflow::GraphExecutionTrace* DebugEvent::unsafe_arena_release_graph_execution_trace() {
2993 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.graph_execution_trace)
2994 if (has_graph_execution_trace()) {
2995 clear_has_what();
2996 ::tensorflow::GraphExecutionTrace* temp = what_.graph_execution_trace_;
2997 what_.graph_execution_trace_ = nullptr;
2998 return temp;
2999 } else {
3000 return nullptr;
3001 }
3002}
3003inline void DebugEvent::unsafe_arena_set_allocated_graph_execution_trace(::tensorflow::GraphExecutionTrace* graph_execution_trace) {
3004 clear_what();
3005 if (graph_execution_trace) {
3006 set_has_graph_execution_trace();
3007 what_.graph_execution_trace_ = graph_execution_trace;
3008 }
3009 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.graph_execution_trace)
3010}
3011inline ::tensorflow::GraphExecutionTrace* DebugEvent::mutable_graph_execution_trace() {
3012 if (!has_graph_execution_trace()) {
3013 clear_what();
3014 set_has_graph_execution_trace();
3015 what_.graph_execution_trace_ = CreateMaybeMessage< ::tensorflow::GraphExecutionTrace >(
3016 GetArenaNoVirtual());
3017 }
3018 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.graph_execution_trace)
3019 return what_.graph_execution_trace_;
3020}
3021
3022// string graph_id = 11;
3023inline bool DebugEvent::has_graph_id() const {
3024 return what_case() == kGraphId;
3025}
3026inline void DebugEvent::set_has_graph_id() {
3027 _oneof_case_[0] = kGraphId;
3028}
3029inline void DebugEvent::clear_graph_id() {
3030 if (has_graph_id()) {
3031 what_.graph_id_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3032 GetArenaNoVirtual());
3033 clear_has_what();
3034 }
3035}
3036inline const std::string& DebugEvent::graph_id() const {
3037 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.graph_id)
3038 if (has_graph_id()) {
3039 return what_.graph_id_.Get();
3040 }
3041 return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
3042}
3043inline void DebugEvent::set_graph_id(const std::string& value) {
3044 if (!has_graph_id()) {
3045 clear_what();
3046 set_has_graph_id();
3047 what_.graph_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3048 }
3049 what_.graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
3050 GetArenaNoVirtual());
3051 // @@protoc_insertion_point(field_set:tensorflow.DebugEvent.graph_id)
3052}
3053inline void DebugEvent::set_graph_id(std::string&& value) {
3054 // @@protoc_insertion_point(field_set:tensorflow.DebugEvent.graph_id)
3055 if (!has_graph_id()) {
3056 clear_what();
3057 set_has_graph_id();
3058 what_.graph_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3059 }
3060 what_.graph_id_.Set(
3061 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3062 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebugEvent.graph_id)
3063}
3064inline void DebugEvent::set_graph_id(const char* value) {
3065 GOOGLE_DCHECK(value != nullptr);
3066 if (!has_graph_id()) {
3067 clear_what();
3068 set_has_graph_id();
3069 what_.graph_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3070 }
3071 what_.graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3072 ::std::string(value), GetArenaNoVirtual());
3073 // @@protoc_insertion_point(field_set_char:tensorflow.DebugEvent.graph_id)
3074}
3075inline void DebugEvent::set_graph_id(const char* value,
3076 size_t size) {
3077 if (!has_graph_id()) {
3078 clear_what();
3079 set_has_graph_id();
3080 what_.graph_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3081 }
3082 what_.graph_id_.Set(
3083 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3084 reinterpret_cast<const char*>(value), size),
3085 GetArenaNoVirtual());
3086 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebugEvent.graph_id)
3087}
3088inline std::string* DebugEvent::mutable_graph_id() {
3089 if (!has_graph_id()) {
3090 clear_what();
3091 set_has_graph_id();
3092 what_.graph_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3093 }
3094 return what_.graph_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3095 GetArenaNoVirtual());
3096 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.graph_id)
3097}
3098inline std::string* DebugEvent::release_graph_id() {
3099 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.graph_id)
3100 if (has_graph_id()) {
3101 clear_has_what();
3102 return what_.graph_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3103 GetArenaNoVirtual());
3104 } else {
3105 return nullptr;
3106 }
3107}
3108inline void DebugEvent::set_allocated_graph_id(std::string* graph_id) {
3109 if (has_what()) {
3110 clear_what();
3111 }
3112 if (graph_id != nullptr) {
3113 set_has_graph_id();
3114 what_.graph_id_.UnsafeSetDefault(graph_id);
3115 }
3116 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebugEvent.graph_id)
3117}
3118inline std::string* DebugEvent::unsafe_arena_release_graph_id() {
3119 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.graph_id)
3120 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3121 if (has_graph_id()) {
3122 clear_has_what();
3123 return what_.graph_id_.UnsafeArenaRelease(
3124 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3125 } else {
3126 return nullptr;
3127 }
3128}
3129inline void DebugEvent::unsafe_arena_set_allocated_graph_id(std::string* graph_id) {
3130 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3131 if (!has_graph_id()) {
3132 what_.graph_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
3133 }
3134 clear_what();
3135 if (graph_id) {
3136 set_has_graph_id();
3137 what_.graph_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), graph_id, GetArenaNoVirtual());
3138 }
3139 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.graph_id)
3140}
3141
3142// .tensorflow.DebuggedDevice debugged_device = 12;
3143inline bool DebugEvent::has_debugged_device() const {
3144 return what_case() == kDebuggedDevice;
3145}
3146inline void DebugEvent::set_has_debugged_device() {
3147 _oneof_case_[0] = kDebuggedDevice;
3148}
3149inline void DebugEvent::clear_debugged_device() {
3150 if (has_debugged_device()) {
3151 if (GetArenaNoVirtual() == nullptr) {
3152 delete what_.debugged_device_;
3153 }
3154 clear_has_what();
3155 }
3156}
3157inline ::tensorflow::DebuggedDevice* DebugEvent::release_debugged_device() {
3158 // @@protoc_insertion_point(field_release:tensorflow.DebugEvent.debugged_device)
3159 if (has_debugged_device()) {
3160 clear_has_what();
3161 ::tensorflow::DebuggedDevice* temp = what_.debugged_device_;
3162 if (GetArenaNoVirtual() != nullptr) {
3163 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3164 }
3165 what_.debugged_device_ = nullptr;
3166 return temp;
3167 } else {
3168 return nullptr;
3169 }
3170}
3171inline const ::tensorflow::DebuggedDevice& DebugEvent::debugged_device() const {
3172 // @@protoc_insertion_point(field_get:tensorflow.DebugEvent.debugged_device)
3173 return has_debugged_device()
3174 ? *what_.debugged_device_
3175 : *reinterpret_cast< ::tensorflow::DebuggedDevice*>(&::tensorflow::_DebuggedDevice_default_instance_);
3176}
3177inline ::tensorflow::DebuggedDevice* DebugEvent::unsafe_arena_release_debugged_device() {
3178 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugEvent.debugged_device)
3179 if (has_debugged_device()) {
3180 clear_has_what();
3181 ::tensorflow::DebuggedDevice* temp = what_.debugged_device_;
3182 what_.debugged_device_ = nullptr;
3183 return temp;
3184 } else {
3185 return nullptr;
3186 }
3187}
3188inline void DebugEvent::unsafe_arena_set_allocated_debugged_device(::tensorflow::DebuggedDevice* debugged_device) {
3189 clear_what();
3190 if (debugged_device) {
3191 set_has_debugged_device();
3192 what_.debugged_device_ = debugged_device;
3193 }
3194 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugEvent.debugged_device)
3195}
3196inline ::tensorflow::DebuggedDevice* DebugEvent::mutable_debugged_device() {
3197 if (!has_debugged_device()) {
3198 clear_what();
3199 set_has_debugged_device();
3200 what_.debugged_device_ = CreateMaybeMessage< ::tensorflow::DebuggedDevice >(
3201 GetArenaNoVirtual());
3202 }
3203 // @@protoc_insertion_point(field_mutable:tensorflow.DebugEvent.debugged_device)
3204 return what_.debugged_device_;
3205}
3206
3207inline bool DebugEvent::has_what() const {
3208 return what_case() != WHAT_NOT_SET;
3209}
3210inline void DebugEvent::clear_has_what() {
3211 _oneof_case_[0] = WHAT_NOT_SET;
3212}
3213inline DebugEvent::WhatCase DebugEvent::what_case() const {
3214 return DebugEvent::WhatCase(_oneof_case_[0]);
3215}
3216// -------------------------------------------------------------------
3217
3218// DebugMetadata
3219
3220// string tensorflow_version = 1;
3221inline void DebugMetadata::clear_tensorflow_version() {
3222 tensorflow_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3223}
3224inline const std::string& DebugMetadata::tensorflow_version() const {
3225 // @@protoc_insertion_point(field_get:tensorflow.DebugMetadata.tensorflow_version)
3226 return tensorflow_version_.Get();
3227}
3228inline void DebugMetadata::set_tensorflow_version(const std::string& value) {
3229
3230 tensorflow_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3231 // @@protoc_insertion_point(field_set:tensorflow.DebugMetadata.tensorflow_version)
3232}
3233inline void DebugMetadata::set_tensorflow_version(std::string&& value) {
3234
3235 tensorflow_version_.Set(
3236 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3237 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebugMetadata.tensorflow_version)
3238}
3239inline void DebugMetadata::set_tensorflow_version(const char* value) {
3240 GOOGLE_DCHECK(value != nullptr);
3241
3242 tensorflow_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3243 GetArenaNoVirtual());
3244 // @@protoc_insertion_point(field_set_char:tensorflow.DebugMetadata.tensorflow_version)
3245}
3246inline void DebugMetadata::set_tensorflow_version(const char* value,
3247 size_t size) {
3248
3249 tensorflow_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3250 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3251 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebugMetadata.tensorflow_version)
3252}
3253inline std::string* DebugMetadata::mutable_tensorflow_version() {
3254
3255 // @@protoc_insertion_point(field_mutable:tensorflow.DebugMetadata.tensorflow_version)
3256 return tensorflow_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3257}
3258inline std::string* DebugMetadata::release_tensorflow_version() {
3259 // @@protoc_insertion_point(field_release:tensorflow.DebugMetadata.tensorflow_version)
3260
3261 return tensorflow_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3262}
3263inline void DebugMetadata::set_allocated_tensorflow_version(std::string* tensorflow_version) {
3264 if (tensorflow_version != nullptr) {
3265
3266 } else {
3267
3268 }
3269 tensorflow_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tensorflow_version,
3270 GetArenaNoVirtual());
3271 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebugMetadata.tensorflow_version)
3272}
3273inline std::string* DebugMetadata::unsafe_arena_release_tensorflow_version() {
3274 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugMetadata.tensorflow_version)
3275 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3276
3277 return tensorflow_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3278 GetArenaNoVirtual());
3279}
3280inline void DebugMetadata::unsafe_arena_set_allocated_tensorflow_version(
3281 std::string* tensorflow_version) {
3282 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3283 if (tensorflow_version != nullptr) {
3284
3285 } else {
3286
3287 }
3288 tensorflow_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3289 tensorflow_version, GetArenaNoVirtual());
3290 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugMetadata.tensorflow_version)
3291}
3292
3293// string file_version = 2;
3294inline void DebugMetadata::clear_file_version() {
3295 file_version_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3296}
3297inline const std::string& DebugMetadata::file_version() const {
3298 // @@protoc_insertion_point(field_get:tensorflow.DebugMetadata.file_version)
3299 return file_version_.Get();
3300}
3301inline void DebugMetadata::set_file_version(const std::string& value) {
3302
3303 file_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3304 // @@protoc_insertion_point(field_set:tensorflow.DebugMetadata.file_version)
3305}
3306inline void DebugMetadata::set_file_version(std::string&& value) {
3307
3308 file_version_.Set(
3309 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3310 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebugMetadata.file_version)
3311}
3312inline void DebugMetadata::set_file_version(const char* value) {
3313 GOOGLE_DCHECK(value != nullptr);
3314
3315 file_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3316 GetArenaNoVirtual());
3317 // @@protoc_insertion_point(field_set_char:tensorflow.DebugMetadata.file_version)
3318}
3319inline void DebugMetadata::set_file_version(const char* value,
3320 size_t size) {
3321
3322 file_version_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3323 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3324 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebugMetadata.file_version)
3325}
3326inline std::string* DebugMetadata::mutable_file_version() {
3327
3328 // @@protoc_insertion_point(field_mutable:tensorflow.DebugMetadata.file_version)
3329 return file_version_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3330}
3331inline std::string* DebugMetadata::release_file_version() {
3332 // @@protoc_insertion_point(field_release:tensorflow.DebugMetadata.file_version)
3333
3334 return file_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3335}
3336inline void DebugMetadata::set_allocated_file_version(std::string* file_version) {
3337 if (file_version != nullptr) {
3338
3339 } else {
3340
3341 }
3342 file_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_version,
3343 GetArenaNoVirtual());
3344 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebugMetadata.file_version)
3345}
3346inline std::string* DebugMetadata::unsafe_arena_release_file_version() {
3347 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugMetadata.file_version)
3348 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3349
3350 return file_version_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3351 GetArenaNoVirtual());
3352}
3353inline void DebugMetadata::unsafe_arena_set_allocated_file_version(
3354 std::string* file_version) {
3355 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3356 if (file_version != nullptr) {
3357
3358 } else {
3359
3360 }
3361 file_version_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3362 file_version, GetArenaNoVirtual());
3363 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugMetadata.file_version)
3364}
3365
3366// string tfdbg_run_id = 3;
3367inline void DebugMetadata::clear_tfdbg_run_id() {
3368 tfdbg_run_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3369}
3370inline const std::string& DebugMetadata::tfdbg_run_id() const {
3371 // @@protoc_insertion_point(field_get:tensorflow.DebugMetadata.tfdbg_run_id)
3372 return tfdbg_run_id_.Get();
3373}
3374inline void DebugMetadata::set_tfdbg_run_id(const std::string& value) {
3375
3376 tfdbg_run_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3377 // @@protoc_insertion_point(field_set:tensorflow.DebugMetadata.tfdbg_run_id)
3378}
3379inline void DebugMetadata::set_tfdbg_run_id(std::string&& value) {
3380
3381 tfdbg_run_id_.Set(
3382 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3383 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebugMetadata.tfdbg_run_id)
3384}
3385inline void DebugMetadata::set_tfdbg_run_id(const char* value) {
3386 GOOGLE_DCHECK(value != nullptr);
3387
3388 tfdbg_run_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3389 GetArenaNoVirtual());
3390 // @@protoc_insertion_point(field_set_char:tensorflow.DebugMetadata.tfdbg_run_id)
3391}
3392inline void DebugMetadata::set_tfdbg_run_id(const char* value,
3393 size_t size) {
3394
3395 tfdbg_run_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3396 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3397 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebugMetadata.tfdbg_run_id)
3398}
3399inline std::string* DebugMetadata::mutable_tfdbg_run_id() {
3400
3401 // @@protoc_insertion_point(field_mutable:tensorflow.DebugMetadata.tfdbg_run_id)
3402 return tfdbg_run_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3403}
3404inline std::string* DebugMetadata::release_tfdbg_run_id() {
3405 // @@protoc_insertion_point(field_release:tensorflow.DebugMetadata.tfdbg_run_id)
3406
3407 return tfdbg_run_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3408}
3409inline void DebugMetadata::set_allocated_tfdbg_run_id(std::string* tfdbg_run_id) {
3410 if (tfdbg_run_id != nullptr) {
3411
3412 } else {
3413
3414 }
3415 tfdbg_run_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tfdbg_run_id,
3416 GetArenaNoVirtual());
3417 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebugMetadata.tfdbg_run_id)
3418}
3419inline std::string* DebugMetadata::unsafe_arena_release_tfdbg_run_id() {
3420 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebugMetadata.tfdbg_run_id)
3421 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3422
3423 return tfdbg_run_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3424 GetArenaNoVirtual());
3425}
3426inline void DebugMetadata::unsafe_arena_set_allocated_tfdbg_run_id(
3427 std::string* tfdbg_run_id) {
3428 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3429 if (tfdbg_run_id != nullptr) {
3430
3431 } else {
3432
3433 }
3434 tfdbg_run_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3435 tfdbg_run_id, GetArenaNoVirtual());
3436 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebugMetadata.tfdbg_run_id)
3437}
3438
3439// -------------------------------------------------------------------
3440
3441// SourceFile
3442
3443// string file_path = 1;
3444inline void SourceFile::clear_file_path() {
3445 file_path_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3446}
3447inline const std::string& SourceFile::file_path() const {
3448 // @@protoc_insertion_point(field_get:tensorflow.SourceFile.file_path)
3449 return file_path_.Get();
3450}
3451inline void SourceFile::set_file_path(const std::string& value) {
3452
3453 file_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3454 // @@protoc_insertion_point(field_set:tensorflow.SourceFile.file_path)
3455}
3456inline void SourceFile::set_file_path(std::string&& value) {
3457
3458 file_path_.Set(
3459 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3460 // @@protoc_insertion_point(field_set_rvalue:tensorflow.SourceFile.file_path)
3461}
3462inline void SourceFile::set_file_path(const char* value) {
3463 GOOGLE_DCHECK(value != nullptr);
3464
3465 file_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3466 GetArenaNoVirtual());
3467 // @@protoc_insertion_point(field_set_char:tensorflow.SourceFile.file_path)
3468}
3469inline void SourceFile::set_file_path(const char* value,
3470 size_t size) {
3471
3472 file_path_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3473 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3474 // @@protoc_insertion_point(field_set_pointer:tensorflow.SourceFile.file_path)
3475}
3476inline std::string* SourceFile::mutable_file_path() {
3477
3478 // @@protoc_insertion_point(field_mutable:tensorflow.SourceFile.file_path)
3479 return file_path_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3480}
3481inline std::string* SourceFile::release_file_path() {
3482 // @@protoc_insertion_point(field_release:tensorflow.SourceFile.file_path)
3483
3484 return file_path_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3485}
3486inline void SourceFile::set_allocated_file_path(std::string* file_path) {
3487 if (file_path != nullptr) {
3488
3489 } else {
3490
3491 }
3492 file_path_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_path,
3493 GetArenaNoVirtual());
3494 // @@protoc_insertion_point(field_set_allocated:tensorflow.SourceFile.file_path)
3495}
3496inline std::string* SourceFile::unsafe_arena_release_file_path() {
3497 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SourceFile.file_path)
3498 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3499
3500 return file_path_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3501 GetArenaNoVirtual());
3502}
3503inline void SourceFile::unsafe_arena_set_allocated_file_path(
3504 std::string* file_path) {
3505 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3506 if (file_path != nullptr) {
3507
3508 } else {
3509
3510 }
3511 file_path_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3512 file_path, GetArenaNoVirtual());
3513 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SourceFile.file_path)
3514}
3515
3516// string host_name = 2;
3517inline void SourceFile::clear_host_name() {
3518 host_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3519}
3520inline const std::string& SourceFile::host_name() const {
3521 // @@protoc_insertion_point(field_get:tensorflow.SourceFile.host_name)
3522 return host_name_.Get();
3523}
3524inline void SourceFile::set_host_name(const std::string& value) {
3525
3526 host_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3527 // @@protoc_insertion_point(field_set:tensorflow.SourceFile.host_name)
3528}
3529inline void SourceFile::set_host_name(std::string&& value) {
3530
3531 host_name_.Set(
3532 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3533 // @@protoc_insertion_point(field_set_rvalue:tensorflow.SourceFile.host_name)
3534}
3535inline void SourceFile::set_host_name(const char* value) {
3536 GOOGLE_DCHECK(value != nullptr);
3537
3538 host_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3539 GetArenaNoVirtual());
3540 // @@protoc_insertion_point(field_set_char:tensorflow.SourceFile.host_name)
3541}
3542inline void SourceFile::set_host_name(const char* value,
3543 size_t size) {
3544
3545 host_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3546 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3547 // @@protoc_insertion_point(field_set_pointer:tensorflow.SourceFile.host_name)
3548}
3549inline std::string* SourceFile::mutable_host_name() {
3550
3551 // @@protoc_insertion_point(field_mutable:tensorflow.SourceFile.host_name)
3552 return host_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3553}
3554inline std::string* SourceFile::release_host_name() {
3555 // @@protoc_insertion_point(field_release:tensorflow.SourceFile.host_name)
3556
3557 return host_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3558}
3559inline void SourceFile::set_allocated_host_name(std::string* host_name) {
3560 if (host_name != nullptr) {
3561
3562 } else {
3563
3564 }
3565 host_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), host_name,
3566 GetArenaNoVirtual());
3567 // @@protoc_insertion_point(field_set_allocated:tensorflow.SourceFile.host_name)
3568}
3569inline std::string* SourceFile::unsafe_arena_release_host_name() {
3570 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.SourceFile.host_name)
3571 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3572
3573 return host_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3574 GetArenaNoVirtual());
3575}
3576inline void SourceFile::unsafe_arena_set_allocated_host_name(
3577 std::string* host_name) {
3578 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3579 if (host_name != nullptr) {
3580
3581 } else {
3582
3583 }
3584 host_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3585 host_name, GetArenaNoVirtual());
3586 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.SourceFile.host_name)
3587}
3588
3589// repeated string lines = 3;
3590inline int SourceFile::lines_size() const {
3591 return lines_.size();
3592}
3593inline void SourceFile::clear_lines() {
3594 lines_.Clear();
3595}
3596inline const std::string& SourceFile::lines(int index) const {
3597 // @@protoc_insertion_point(field_get:tensorflow.SourceFile.lines)
3598 return lines_.Get(index);
3599}
3600inline std::string* SourceFile::mutable_lines(int index) {
3601 // @@protoc_insertion_point(field_mutable:tensorflow.SourceFile.lines)
3602 return lines_.Mutable(index);
3603}
3604inline void SourceFile::set_lines(int index, const std::string& value) {
3605 // @@protoc_insertion_point(field_set:tensorflow.SourceFile.lines)
3606 lines_.Mutable(index)->assign(value);
3607}
3608inline void SourceFile::set_lines(int index, std::string&& value) {
3609 // @@protoc_insertion_point(field_set:tensorflow.SourceFile.lines)
3610 lines_.Mutable(index)->assign(std::move(value));
3611}
3612inline void SourceFile::set_lines(int index, const char* value) {
3613 GOOGLE_DCHECK(value != nullptr);
3614 lines_.Mutable(index)->assign(value);
3615 // @@protoc_insertion_point(field_set_char:tensorflow.SourceFile.lines)
3616}
3617inline void SourceFile::set_lines(int index, const char* value, size_t size) {
3618 lines_.Mutable(index)->assign(
3619 reinterpret_cast<const char*>(value), size);
3620 // @@protoc_insertion_point(field_set_pointer:tensorflow.SourceFile.lines)
3621}
3622inline std::string* SourceFile::add_lines() {
3623 // @@protoc_insertion_point(field_add_mutable:tensorflow.SourceFile.lines)
3624 return lines_.Add();
3625}
3626inline void SourceFile::add_lines(const std::string& value) {
3627 lines_.Add()->assign(value);
3628 // @@protoc_insertion_point(field_add:tensorflow.SourceFile.lines)
3629}
3630inline void SourceFile::add_lines(std::string&& value) {
3631 lines_.Add(std::move(value));
3632 // @@protoc_insertion_point(field_add:tensorflow.SourceFile.lines)
3633}
3634inline void SourceFile::add_lines(const char* value) {
3635 GOOGLE_DCHECK(value != nullptr);
3636 lines_.Add()->assign(value);
3637 // @@protoc_insertion_point(field_add_char:tensorflow.SourceFile.lines)
3638}
3639inline void SourceFile::add_lines(const char* value, size_t size) {
3640 lines_.Add()->assign(reinterpret_cast<const char*>(value), size);
3641 // @@protoc_insertion_point(field_add_pointer:tensorflow.SourceFile.lines)
3642}
3643inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
3644SourceFile::lines() const {
3645 // @@protoc_insertion_point(field_list:tensorflow.SourceFile.lines)
3646 return lines_;
3647}
3648inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
3649SourceFile::mutable_lines() {
3650 // @@protoc_insertion_point(field_mutable_list:tensorflow.SourceFile.lines)
3651 return &lines_;
3652}
3653
3654// -------------------------------------------------------------------
3655
3656// StackFrameWithId
3657
3658// string id = 1;
3659inline void StackFrameWithId::clear_id() {
3660 id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3661}
3662inline const std::string& StackFrameWithId::id() const {
3663 // @@protoc_insertion_point(field_get:tensorflow.StackFrameWithId.id)
3664 return id_.Get();
3665}
3666inline void StackFrameWithId::set_id(const std::string& value) {
3667
3668 id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3669 // @@protoc_insertion_point(field_set:tensorflow.StackFrameWithId.id)
3670}
3671inline void StackFrameWithId::set_id(std::string&& value) {
3672
3673 id_.Set(
3674 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3675 // @@protoc_insertion_point(field_set_rvalue:tensorflow.StackFrameWithId.id)
3676}
3677inline void StackFrameWithId::set_id(const char* value) {
3678 GOOGLE_DCHECK(value != nullptr);
3679
3680 id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3681 GetArenaNoVirtual());
3682 // @@protoc_insertion_point(field_set_char:tensorflow.StackFrameWithId.id)
3683}
3684inline void StackFrameWithId::set_id(const char* value,
3685 size_t size) {
3686
3687 id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3688 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3689 // @@protoc_insertion_point(field_set_pointer:tensorflow.StackFrameWithId.id)
3690}
3691inline std::string* StackFrameWithId::mutable_id() {
3692
3693 // @@protoc_insertion_point(field_mutable:tensorflow.StackFrameWithId.id)
3694 return id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3695}
3696inline std::string* StackFrameWithId::release_id() {
3697 // @@protoc_insertion_point(field_release:tensorflow.StackFrameWithId.id)
3698
3699 return id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3700}
3701inline void StackFrameWithId::set_allocated_id(std::string* id) {
3702 if (id != nullptr) {
3703
3704 } else {
3705
3706 }
3707 id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
3708 GetArenaNoVirtual());
3709 // @@protoc_insertion_point(field_set_allocated:tensorflow.StackFrameWithId.id)
3710}
3711inline std::string* StackFrameWithId::unsafe_arena_release_id() {
3712 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.StackFrameWithId.id)
3713 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3714
3715 return id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3716 GetArenaNoVirtual());
3717}
3718inline void StackFrameWithId::unsafe_arena_set_allocated_id(
3719 std::string* id) {
3720 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3721 if (id != nullptr) {
3722
3723 } else {
3724
3725 }
3726 id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3727 id, GetArenaNoVirtual());
3728 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.StackFrameWithId.id)
3729}
3730
3731// .tensorflow.GraphDebugInfo.FileLineCol file_line_col = 2;
3732inline bool StackFrameWithId::has_file_line_col() const {
3733 return this != internal_default_instance() && file_line_col_ != nullptr;
3734}
3735inline const ::tensorflow::GraphDebugInfo_FileLineCol& StackFrameWithId::file_line_col() const {
3736 const ::tensorflow::GraphDebugInfo_FileLineCol* p = file_line_col_;
3737 // @@protoc_insertion_point(field_get:tensorflow.StackFrameWithId.file_line_col)
3738 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::GraphDebugInfo_FileLineCol*>(
3739 &::tensorflow::_GraphDebugInfo_FileLineCol_default_instance_);
3740}
3741inline ::tensorflow::GraphDebugInfo_FileLineCol* StackFrameWithId::release_file_line_col() {
3742 // @@protoc_insertion_point(field_release:tensorflow.StackFrameWithId.file_line_col)
3743
3744 ::tensorflow::GraphDebugInfo_FileLineCol* temp = file_line_col_;
3745 if (GetArenaNoVirtual() != nullptr) {
3746 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
3747 }
3748 file_line_col_ = nullptr;
3749 return temp;
3750}
3751inline ::tensorflow::GraphDebugInfo_FileLineCol* StackFrameWithId::unsafe_arena_release_file_line_col() {
3752 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.StackFrameWithId.file_line_col)
3753
3754 ::tensorflow::GraphDebugInfo_FileLineCol* temp = file_line_col_;
3755 file_line_col_ = nullptr;
3756 return temp;
3757}
3758inline ::tensorflow::GraphDebugInfo_FileLineCol* StackFrameWithId::mutable_file_line_col() {
3759
3760 if (file_line_col_ == nullptr) {
3761 auto* p = CreateMaybeMessage<::tensorflow::GraphDebugInfo_FileLineCol>(GetArenaNoVirtual());
3762 file_line_col_ = p;
3763 }
3764 // @@protoc_insertion_point(field_mutable:tensorflow.StackFrameWithId.file_line_col)
3765 return file_line_col_;
3766}
3767inline void StackFrameWithId::set_allocated_file_line_col(::tensorflow::GraphDebugInfo_FileLineCol* file_line_col) {
3768 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
3769 if (message_arena == nullptr) {
3770 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(file_line_col_);
3771 }
3772 if (file_line_col) {
3773 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
3774 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(file_line_col)->GetArena();
3775 if (message_arena != submessage_arena) {
3776 file_line_col = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
3777 message_arena, file_line_col, submessage_arena);
3778 }
3779
3780 } else {
3781
3782 }
3783 file_line_col_ = file_line_col;
3784 // @@protoc_insertion_point(field_set_allocated:tensorflow.StackFrameWithId.file_line_col)
3785}
3786
3787// -------------------------------------------------------------------
3788
3789// CodeLocation
3790
3791// string host_name = 1;
3792inline void CodeLocation::clear_host_name() {
3793 host_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3794}
3795inline const std::string& CodeLocation::host_name() const {
3796 // @@protoc_insertion_point(field_get:tensorflow.CodeLocation.host_name)
3797 return host_name_.Get();
3798}
3799inline void CodeLocation::set_host_name(const std::string& value) {
3800
3801 host_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3802 // @@protoc_insertion_point(field_set:tensorflow.CodeLocation.host_name)
3803}
3804inline void CodeLocation::set_host_name(std::string&& value) {
3805
3806 host_name_.Set(
3807 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3808 // @@protoc_insertion_point(field_set_rvalue:tensorflow.CodeLocation.host_name)
3809}
3810inline void CodeLocation::set_host_name(const char* value) {
3811 GOOGLE_DCHECK(value != nullptr);
3812
3813 host_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3814 GetArenaNoVirtual());
3815 // @@protoc_insertion_point(field_set_char:tensorflow.CodeLocation.host_name)
3816}
3817inline void CodeLocation::set_host_name(const char* value,
3818 size_t size) {
3819
3820 host_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3821 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3822 // @@protoc_insertion_point(field_set_pointer:tensorflow.CodeLocation.host_name)
3823}
3824inline std::string* CodeLocation::mutable_host_name() {
3825
3826 // @@protoc_insertion_point(field_mutable:tensorflow.CodeLocation.host_name)
3827 return host_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3828}
3829inline std::string* CodeLocation::release_host_name() {
3830 // @@protoc_insertion_point(field_release:tensorflow.CodeLocation.host_name)
3831
3832 return host_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3833}
3834inline void CodeLocation::set_allocated_host_name(std::string* host_name) {
3835 if (host_name != nullptr) {
3836
3837 } else {
3838
3839 }
3840 host_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), host_name,
3841 GetArenaNoVirtual());
3842 // @@protoc_insertion_point(field_set_allocated:tensorflow.CodeLocation.host_name)
3843}
3844inline std::string* CodeLocation::unsafe_arena_release_host_name() {
3845 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.CodeLocation.host_name)
3846 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3847
3848 return host_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3849 GetArenaNoVirtual());
3850}
3851inline void CodeLocation::unsafe_arena_set_allocated_host_name(
3852 std::string* host_name) {
3853 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3854 if (host_name != nullptr) {
3855
3856 } else {
3857
3858 }
3859 host_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3860 host_name, GetArenaNoVirtual());
3861 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.CodeLocation.host_name)
3862}
3863
3864// repeated string stack_frame_ids = 2;
3865inline int CodeLocation::stack_frame_ids_size() const {
3866 return stack_frame_ids_.size();
3867}
3868inline void CodeLocation::clear_stack_frame_ids() {
3869 stack_frame_ids_.Clear();
3870}
3871inline const std::string& CodeLocation::stack_frame_ids(int index) const {
3872 // @@protoc_insertion_point(field_get:tensorflow.CodeLocation.stack_frame_ids)
3873 return stack_frame_ids_.Get(index);
3874}
3875inline std::string* CodeLocation::mutable_stack_frame_ids(int index) {
3876 // @@protoc_insertion_point(field_mutable:tensorflow.CodeLocation.stack_frame_ids)
3877 return stack_frame_ids_.Mutable(index);
3878}
3879inline void CodeLocation::set_stack_frame_ids(int index, const std::string& value) {
3880 // @@protoc_insertion_point(field_set:tensorflow.CodeLocation.stack_frame_ids)
3881 stack_frame_ids_.Mutable(index)->assign(value);
3882}
3883inline void CodeLocation::set_stack_frame_ids(int index, std::string&& value) {
3884 // @@protoc_insertion_point(field_set:tensorflow.CodeLocation.stack_frame_ids)
3885 stack_frame_ids_.Mutable(index)->assign(std::move(value));
3886}
3887inline void CodeLocation::set_stack_frame_ids(int index, const char* value) {
3888 GOOGLE_DCHECK(value != nullptr);
3889 stack_frame_ids_.Mutable(index)->assign(value);
3890 // @@protoc_insertion_point(field_set_char:tensorflow.CodeLocation.stack_frame_ids)
3891}
3892inline void CodeLocation::set_stack_frame_ids(int index, const char* value, size_t size) {
3893 stack_frame_ids_.Mutable(index)->assign(
3894 reinterpret_cast<const char*>(value), size);
3895 // @@protoc_insertion_point(field_set_pointer:tensorflow.CodeLocation.stack_frame_ids)
3896}
3897inline std::string* CodeLocation::add_stack_frame_ids() {
3898 // @@protoc_insertion_point(field_add_mutable:tensorflow.CodeLocation.stack_frame_ids)
3899 return stack_frame_ids_.Add();
3900}
3901inline void CodeLocation::add_stack_frame_ids(const std::string& value) {
3902 stack_frame_ids_.Add()->assign(value);
3903 // @@protoc_insertion_point(field_add:tensorflow.CodeLocation.stack_frame_ids)
3904}
3905inline void CodeLocation::add_stack_frame_ids(std::string&& value) {
3906 stack_frame_ids_.Add(std::move(value));
3907 // @@protoc_insertion_point(field_add:tensorflow.CodeLocation.stack_frame_ids)
3908}
3909inline void CodeLocation::add_stack_frame_ids(const char* value) {
3910 GOOGLE_DCHECK(value != nullptr);
3911 stack_frame_ids_.Add()->assign(value);
3912 // @@protoc_insertion_point(field_add_char:tensorflow.CodeLocation.stack_frame_ids)
3913}
3914inline void CodeLocation::add_stack_frame_ids(const char* value, size_t size) {
3915 stack_frame_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
3916 // @@protoc_insertion_point(field_add_pointer:tensorflow.CodeLocation.stack_frame_ids)
3917}
3918inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
3919CodeLocation::stack_frame_ids() const {
3920 // @@protoc_insertion_point(field_list:tensorflow.CodeLocation.stack_frame_ids)
3921 return stack_frame_ids_;
3922}
3923inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
3924CodeLocation::mutable_stack_frame_ids() {
3925 // @@protoc_insertion_point(field_mutable_list:tensorflow.CodeLocation.stack_frame_ids)
3926 return &stack_frame_ids_;
3927}
3928
3929// -------------------------------------------------------------------
3930
3931// GraphOpCreation
3932
3933// string op_type = 1;
3934inline void GraphOpCreation::clear_op_type() {
3935 op_type_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3936}
3937inline const std::string& GraphOpCreation::op_type() const {
3938 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.op_type)
3939 return op_type_.Get();
3940}
3941inline void GraphOpCreation::set_op_type(const std::string& value) {
3942
3943 op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
3944 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.op_type)
3945}
3946inline void GraphOpCreation::set_op_type(std::string&& value) {
3947
3948 op_type_.Set(
3949 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
3950 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphOpCreation.op_type)
3951}
3952inline void GraphOpCreation::set_op_type(const char* value) {
3953 GOOGLE_DCHECK(value != nullptr);
3954
3955 op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
3956 GetArenaNoVirtual());
3957 // @@protoc_insertion_point(field_set_char:tensorflow.GraphOpCreation.op_type)
3958}
3959inline void GraphOpCreation::set_op_type(const char* value,
3960 size_t size) {
3961
3962 op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
3963 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
3964 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphOpCreation.op_type)
3965}
3966inline std::string* GraphOpCreation::mutable_op_type() {
3967
3968 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.op_type)
3969 return op_type_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3970}
3971inline std::string* GraphOpCreation::release_op_type() {
3972 // @@protoc_insertion_point(field_release:tensorflow.GraphOpCreation.op_type)
3973
3974 return op_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
3975}
3976inline void GraphOpCreation::set_allocated_op_type(std::string* op_type) {
3977 if (op_type != nullptr) {
3978
3979 } else {
3980
3981 }
3982 op_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_type,
3983 GetArenaNoVirtual());
3984 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOpCreation.op_type)
3985}
3986inline std::string* GraphOpCreation::unsafe_arena_release_op_type() {
3987 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOpCreation.op_type)
3988 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3989
3990 return op_type_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
3991 GetArenaNoVirtual());
3992}
3993inline void GraphOpCreation::unsafe_arena_set_allocated_op_type(
3994 std::string* op_type) {
3995 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
3996 if (op_type != nullptr) {
3997
3998 } else {
3999
4000 }
4001 op_type_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4002 op_type, GetArenaNoVirtual());
4003 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphOpCreation.op_type)
4004}
4005
4006// string op_name = 2;
4007inline void GraphOpCreation::clear_op_name() {
4008 op_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4009}
4010inline const std::string& GraphOpCreation::op_name() const {
4011 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.op_name)
4012 return op_name_.Get();
4013}
4014inline void GraphOpCreation::set_op_name(const std::string& value) {
4015
4016 op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4017 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.op_name)
4018}
4019inline void GraphOpCreation::set_op_name(std::string&& value) {
4020
4021 op_name_.Set(
4022 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4023 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphOpCreation.op_name)
4024}
4025inline void GraphOpCreation::set_op_name(const char* value) {
4026 GOOGLE_DCHECK(value != nullptr);
4027
4028 op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4029 GetArenaNoVirtual());
4030 // @@protoc_insertion_point(field_set_char:tensorflow.GraphOpCreation.op_name)
4031}
4032inline void GraphOpCreation::set_op_name(const char* value,
4033 size_t size) {
4034
4035 op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4036 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4037 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphOpCreation.op_name)
4038}
4039inline std::string* GraphOpCreation::mutable_op_name() {
4040
4041 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.op_name)
4042 return op_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4043}
4044inline std::string* GraphOpCreation::release_op_name() {
4045 // @@protoc_insertion_point(field_release:tensorflow.GraphOpCreation.op_name)
4046
4047 return op_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4048}
4049inline void GraphOpCreation::set_allocated_op_name(std::string* op_name) {
4050 if (op_name != nullptr) {
4051
4052 } else {
4053
4054 }
4055 op_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_name,
4056 GetArenaNoVirtual());
4057 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOpCreation.op_name)
4058}
4059inline std::string* GraphOpCreation::unsafe_arena_release_op_name() {
4060 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOpCreation.op_name)
4061 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4062
4063 return op_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4064 GetArenaNoVirtual());
4065}
4066inline void GraphOpCreation::unsafe_arena_set_allocated_op_name(
4067 std::string* op_name) {
4068 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4069 if (op_name != nullptr) {
4070
4071 } else {
4072
4073 }
4074 op_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4075 op_name, GetArenaNoVirtual());
4076 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphOpCreation.op_name)
4077}
4078
4079// string graph_name = 3;
4080inline void GraphOpCreation::clear_graph_name() {
4081 graph_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4082}
4083inline const std::string& GraphOpCreation::graph_name() const {
4084 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.graph_name)
4085 return graph_name_.Get();
4086}
4087inline void GraphOpCreation::set_graph_name(const std::string& value) {
4088
4089 graph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4090 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.graph_name)
4091}
4092inline void GraphOpCreation::set_graph_name(std::string&& value) {
4093
4094 graph_name_.Set(
4095 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4096 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphOpCreation.graph_name)
4097}
4098inline void GraphOpCreation::set_graph_name(const char* value) {
4099 GOOGLE_DCHECK(value != nullptr);
4100
4101 graph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4102 GetArenaNoVirtual());
4103 // @@protoc_insertion_point(field_set_char:tensorflow.GraphOpCreation.graph_name)
4104}
4105inline void GraphOpCreation::set_graph_name(const char* value,
4106 size_t size) {
4107
4108 graph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4109 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4110 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphOpCreation.graph_name)
4111}
4112inline std::string* GraphOpCreation::mutable_graph_name() {
4113
4114 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.graph_name)
4115 return graph_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4116}
4117inline std::string* GraphOpCreation::release_graph_name() {
4118 // @@protoc_insertion_point(field_release:tensorflow.GraphOpCreation.graph_name)
4119
4120 return graph_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4121}
4122inline void GraphOpCreation::set_allocated_graph_name(std::string* graph_name) {
4123 if (graph_name != nullptr) {
4124
4125 } else {
4126
4127 }
4128 graph_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), graph_name,
4129 GetArenaNoVirtual());
4130 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOpCreation.graph_name)
4131}
4132inline std::string* GraphOpCreation::unsafe_arena_release_graph_name() {
4133 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOpCreation.graph_name)
4134 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4135
4136 return graph_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4137 GetArenaNoVirtual());
4138}
4139inline void GraphOpCreation::unsafe_arena_set_allocated_graph_name(
4140 std::string* graph_name) {
4141 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4142 if (graph_name != nullptr) {
4143
4144 } else {
4145
4146 }
4147 graph_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4148 graph_name, GetArenaNoVirtual());
4149 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphOpCreation.graph_name)
4150}
4151
4152// string graph_id = 4;
4153inline void GraphOpCreation::clear_graph_id() {
4154 graph_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4155}
4156inline const std::string& GraphOpCreation::graph_id() const {
4157 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.graph_id)
4158 return graph_id_.Get();
4159}
4160inline void GraphOpCreation::set_graph_id(const std::string& value) {
4161
4162 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4163 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.graph_id)
4164}
4165inline void GraphOpCreation::set_graph_id(std::string&& value) {
4166
4167 graph_id_.Set(
4168 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4169 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphOpCreation.graph_id)
4170}
4171inline void GraphOpCreation::set_graph_id(const char* value) {
4172 GOOGLE_DCHECK(value != nullptr);
4173
4174 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4175 GetArenaNoVirtual());
4176 // @@protoc_insertion_point(field_set_char:tensorflow.GraphOpCreation.graph_id)
4177}
4178inline void GraphOpCreation::set_graph_id(const char* value,
4179 size_t size) {
4180
4181 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4182 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4183 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphOpCreation.graph_id)
4184}
4185inline std::string* GraphOpCreation::mutable_graph_id() {
4186
4187 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.graph_id)
4188 return graph_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4189}
4190inline std::string* GraphOpCreation::release_graph_id() {
4191 // @@protoc_insertion_point(field_release:tensorflow.GraphOpCreation.graph_id)
4192
4193 return graph_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4194}
4195inline void GraphOpCreation::set_allocated_graph_id(std::string* graph_id) {
4196 if (graph_id != nullptr) {
4197
4198 } else {
4199
4200 }
4201 graph_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), graph_id,
4202 GetArenaNoVirtual());
4203 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOpCreation.graph_id)
4204}
4205inline std::string* GraphOpCreation::unsafe_arena_release_graph_id() {
4206 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOpCreation.graph_id)
4207 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4208
4209 return graph_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4210 GetArenaNoVirtual());
4211}
4212inline void GraphOpCreation::unsafe_arena_set_allocated_graph_id(
4213 std::string* graph_id) {
4214 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4215 if (graph_id != nullptr) {
4216
4217 } else {
4218
4219 }
4220 graph_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4221 graph_id, GetArenaNoVirtual());
4222 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphOpCreation.graph_id)
4223}
4224
4225// string device_name = 5;
4226inline void GraphOpCreation::clear_device_name() {
4227 device_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4228}
4229inline const std::string& GraphOpCreation::device_name() const {
4230 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.device_name)
4231 return device_name_.Get();
4232}
4233inline void GraphOpCreation::set_device_name(const std::string& value) {
4234
4235 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4236 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.device_name)
4237}
4238inline void GraphOpCreation::set_device_name(std::string&& value) {
4239
4240 device_name_.Set(
4241 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4242 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphOpCreation.device_name)
4243}
4244inline void GraphOpCreation::set_device_name(const char* value) {
4245 GOOGLE_DCHECK(value != nullptr);
4246
4247 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4248 GetArenaNoVirtual());
4249 // @@protoc_insertion_point(field_set_char:tensorflow.GraphOpCreation.device_name)
4250}
4251inline void GraphOpCreation::set_device_name(const char* value,
4252 size_t size) {
4253
4254 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4255 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4256 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphOpCreation.device_name)
4257}
4258inline std::string* GraphOpCreation::mutable_device_name() {
4259
4260 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.device_name)
4261 return device_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4262}
4263inline std::string* GraphOpCreation::release_device_name() {
4264 // @@protoc_insertion_point(field_release:tensorflow.GraphOpCreation.device_name)
4265
4266 return device_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4267}
4268inline void GraphOpCreation::set_allocated_device_name(std::string* device_name) {
4269 if (device_name != nullptr) {
4270
4271 } else {
4272
4273 }
4274 device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_name,
4275 GetArenaNoVirtual());
4276 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOpCreation.device_name)
4277}
4278inline std::string* GraphOpCreation::unsafe_arena_release_device_name() {
4279 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOpCreation.device_name)
4280 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4281
4282 return device_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4283 GetArenaNoVirtual());
4284}
4285inline void GraphOpCreation::unsafe_arena_set_allocated_device_name(
4286 std::string* device_name) {
4287 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4288 if (device_name != nullptr) {
4289
4290 } else {
4291
4292 }
4293 device_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4294 device_name, GetArenaNoVirtual());
4295 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphOpCreation.device_name)
4296}
4297
4298// repeated string input_names = 6;
4299inline int GraphOpCreation::input_names_size() const {
4300 return input_names_.size();
4301}
4302inline void GraphOpCreation::clear_input_names() {
4303 input_names_.Clear();
4304}
4305inline const std::string& GraphOpCreation::input_names(int index) const {
4306 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.input_names)
4307 return input_names_.Get(index);
4308}
4309inline std::string* GraphOpCreation::mutable_input_names(int index) {
4310 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.input_names)
4311 return input_names_.Mutable(index);
4312}
4313inline void GraphOpCreation::set_input_names(int index, const std::string& value) {
4314 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.input_names)
4315 input_names_.Mutable(index)->assign(value);
4316}
4317inline void GraphOpCreation::set_input_names(int index, std::string&& value) {
4318 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.input_names)
4319 input_names_.Mutable(index)->assign(std::move(value));
4320}
4321inline void GraphOpCreation::set_input_names(int index, const char* value) {
4322 GOOGLE_DCHECK(value != nullptr);
4323 input_names_.Mutable(index)->assign(value);
4324 // @@protoc_insertion_point(field_set_char:tensorflow.GraphOpCreation.input_names)
4325}
4326inline void GraphOpCreation::set_input_names(int index, const char* value, size_t size) {
4327 input_names_.Mutable(index)->assign(
4328 reinterpret_cast<const char*>(value), size);
4329 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphOpCreation.input_names)
4330}
4331inline std::string* GraphOpCreation::add_input_names() {
4332 // @@protoc_insertion_point(field_add_mutable:tensorflow.GraphOpCreation.input_names)
4333 return input_names_.Add();
4334}
4335inline void GraphOpCreation::add_input_names(const std::string& value) {
4336 input_names_.Add()->assign(value);
4337 // @@protoc_insertion_point(field_add:tensorflow.GraphOpCreation.input_names)
4338}
4339inline void GraphOpCreation::add_input_names(std::string&& value) {
4340 input_names_.Add(std::move(value));
4341 // @@protoc_insertion_point(field_add:tensorflow.GraphOpCreation.input_names)
4342}
4343inline void GraphOpCreation::add_input_names(const char* value) {
4344 GOOGLE_DCHECK(value != nullptr);
4345 input_names_.Add()->assign(value);
4346 // @@protoc_insertion_point(field_add_char:tensorflow.GraphOpCreation.input_names)
4347}
4348inline void GraphOpCreation::add_input_names(const char* value, size_t size) {
4349 input_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
4350 // @@protoc_insertion_point(field_add_pointer:tensorflow.GraphOpCreation.input_names)
4351}
4352inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4353GraphOpCreation::input_names() const {
4354 // @@protoc_insertion_point(field_list:tensorflow.GraphOpCreation.input_names)
4355 return input_names_;
4356}
4357inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4358GraphOpCreation::mutable_input_names() {
4359 // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphOpCreation.input_names)
4360 return &input_names_;
4361}
4362
4363// int32 num_outputs = 7;
4364inline void GraphOpCreation::clear_num_outputs() {
4365 num_outputs_ = 0;
4366}
4367inline ::PROTOBUF_NAMESPACE_ID::int32 GraphOpCreation::num_outputs() const {
4368 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.num_outputs)
4369 return num_outputs_;
4370}
4371inline void GraphOpCreation::set_num_outputs(::PROTOBUF_NAMESPACE_ID::int32 value) {
4372
4373 num_outputs_ = value;
4374 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.num_outputs)
4375}
4376
4377// .tensorflow.CodeLocation code_location = 8;
4378inline bool GraphOpCreation::has_code_location() const {
4379 return this != internal_default_instance() && code_location_ != nullptr;
4380}
4381inline void GraphOpCreation::clear_code_location() {
4382 if (GetArenaNoVirtual() == nullptr && code_location_ != nullptr) {
4383 delete code_location_;
4384 }
4385 code_location_ = nullptr;
4386}
4387inline const ::tensorflow::CodeLocation& GraphOpCreation::code_location() const {
4388 const ::tensorflow::CodeLocation* p = code_location_;
4389 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.code_location)
4390 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CodeLocation*>(
4391 &::tensorflow::_CodeLocation_default_instance_);
4392}
4393inline ::tensorflow::CodeLocation* GraphOpCreation::release_code_location() {
4394 // @@protoc_insertion_point(field_release:tensorflow.GraphOpCreation.code_location)
4395
4396 ::tensorflow::CodeLocation* temp = code_location_;
4397 if (GetArenaNoVirtual() != nullptr) {
4398 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
4399 }
4400 code_location_ = nullptr;
4401 return temp;
4402}
4403inline ::tensorflow::CodeLocation* GraphOpCreation::unsafe_arena_release_code_location() {
4404 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphOpCreation.code_location)
4405
4406 ::tensorflow::CodeLocation* temp = code_location_;
4407 code_location_ = nullptr;
4408 return temp;
4409}
4410inline ::tensorflow::CodeLocation* GraphOpCreation::mutable_code_location() {
4411
4412 if (code_location_ == nullptr) {
4413 auto* p = CreateMaybeMessage<::tensorflow::CodeLocation>(GetArenaNoVirtual());
4414 code_location_ = p;
4415 }
4416 // @@protoc_insertion_point(field_mutable:tensorflow.GraphOpCreation.code_location)
4417 return code_location_;
4418}
4419inline void GraphOpCreation::set_allocated_code_location(::tensorflow::CodeLocation* code_location) {
4420 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
4421 if (message_arena == nullptr) {
4422 delete code_location_;
4423 }
4424 if (code_location) {
4425 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
4426 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(code_location);
4427 if (message_arena != submessage_arena) {
4428 code_location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
4429 message_arena, code_location, submessage_arena);
4430 }
4431
4432 } else {
4433
4434 }
4435 code_location_ = code_location;
4436 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphOpCreation.code_location)
4437}
4438
4439// repeated int32 output_tensor_ids = 9;
4440inline int GraphOpCreation::output_tensor_ids_size() const {
4441 return output_tensor_ids_.size();
4442}
4443inline void GraphOpCreation::clear_output_tensor_ids() {
4444 output_tensor_ids_.Clear();
4445}
4446inline ::PROTOBUF_NAMESPACE_ID::int32 GraphOpCreation::output_tensor_ids(int index) const {
4447 // @@protoc_insertion_point(field_get:tensorflow.GraphOpCreation.output_tensor_ids)
4448 return output_tensor_ids_.Get(index);
4449}
4450inline void GraphOpCreation::set_output_tensor_ids(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
4451 output_tensor_ids_.Set(index, value);
4452 // @@protoc_insertion_point(field_set:tensorflow.GraphOpCreation.output_tensor_ids)
4453}
4454inline void GraphOpCreation::add_output_tensor_ids(::PROTOBUF_NAMESPACE_ID::int32 value) {
4455 output_tensor_ids_.Add(value);
4456 // @@protoc_insertion_point(field_add:tensorflow.GraphOpCreation.output_tensor_ids)
4457}
4458inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
4459GraphOpCreation::output_tensor_ids() const {
4460 // @@protoc_insertion_point(field_list:tensorflow.GraphOpCreation.output_tensor_ids)
4461 return output_tensor_ids_;
4462}
4463inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
4464GraphOpCreation::mutable_output_tensor_ids() {
4465 // @@protoc_insertion_point(field_mutable_list:tensorflow.GraphOpCreation.output_tensor_ids)
4466 return &output_tensor_ids_;
4467}
4468
4469// -------------------------------------------------------------------
4470
4471// DebuggedGraph
4472
4473// string graph_id = 1;
4474inline void DebuggedGraph::clear_graph_id() {
4475 graph_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4476}
4477inline const std::string& DebuggedGraph::graph_id() const {
4478 // @@protoc_insertion_point(field_get:tensorflow.DebuggedGraph.graph_id)
4479 return graph_id_.Get();
4480}
4481inline void DebuggedGraph::set_graph_id(const std::string& value) {
4482
4483 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4484 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.graph_id)
4485}
4486inline void DebuggedGraph::set_graph_id(std::string&& value) {
4487
4488 graph_id_.Set(
4489 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4490 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebuggedGraph.graph_id)
4491}
4492inline void DebuggedGraph::set_graph_id(const char* value) {
4493 GOOGLE_DCHECK(value != nullptr);
4494
4495 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4496 GetArenaNoVirtual());
4497 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedGraph.graph_id)
4498}
4499inline void DebuggedGraph::set_graph_id(const char* value,
4500 size_t size) {
4501
4502 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4503 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4504 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedGraph.graph_id)
4505}
4506inline std::string* DebuggedGraph::mutable_graph_id() {
4507
4508 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedGraph.graph_id)
4509 return graph_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4510}
4511inline std::string* DebuggedGraph::release_graph_id() {
4512 // @@protoc_insertion_point(field_release:tensorflow.DebuggedGraph.graph_id)
4513
4514 return graph_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4515}
4516inline void DebuggedGraph::set_allocated_graph_id(std::string* graph_id) {
4517 if (graph_id != nullptr) {
4518
4519 } else {
4520
4521 }
4522 graph_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), graph_id,
4523 GetArenaNoVirtual());
4524 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedGraph.graph_id)
4525}
4526inline std::string* DebuggedGraph::unsafe_arena_release_graph_id() {
4527 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebuggedGraph.graph_id)
4528 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4529
4530 return graph_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4531 GetArenaNoVirtual());
4532}
4533inline void DebuggedGraph::unsafe_arena_set_allocated_graph_id(
4534 std::string* graph_id) {
4535 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4536 if (graph_id != nullptr) {
4537
4538 } else {
4539
4540 }
4541 graph_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4542 graph_id, GetArenaNoVirtual());
4543 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebuggedGraph.graph_id)
4544}
4545
4546// string graph_name = 2;
4547inline void DebuggedGraph::clear_graph_name() {
4548 graph_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4549}
4550inline const std::string& DebuggedGraph::graph_name() const {
4551 // @@protoc_insertion_point(field_get:tensorflow.DebuggedGraph.graph_name)
4552 return graph_name_.Get();
4553}
4554inline void DebuggedGraph::set_graph_name(const std::string& value) {
4555
4556 graph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4557 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.graph_name)
4558}
4559inline void DebuggedGraph::set_graph_name(std::string&& value) {
4560
4561 graph_name_.Set(
4562 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4563 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebuggedGraph.graph_name)
4564}
4565inline void DebuggedGraph::set_graph_name(const char* value) {
4566 GOOGLE_DCHECK(value != nullptr);
4567
4568 graph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4569 GetArenaNoVirtual());
4570 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedGraph.graph_name)
4571}
4572inline void DebuggedGraph::set_graph_name(const char* value,
4573 size_t size) {
4574
4575 graph_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4576 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4577 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedGraph.graph_name)
4578}
4579inline std::string* DebuggedGraph::mutable_graph_name() {
4580
4581 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedGraph.graph_name)
4582 return graph_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4583}
4584inline std::string* DebuggedGraph::release_graph_name() {
4585 // @@protoc_insertion_point(field_release:tensorflow.DebuggedGraph.graph_name)
4586
4587 return graph_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4588}
4589inline void DebuggedGraph::set_allocated_graph_name(std::string* graph_name) {
4590 if (graph_name != nullptr) {
4591
4592 } else {
4593
4594 }
4595 graph_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), graph_name,
4596 GetArenaNoVirtual());
4597 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedGraph.graph_name)
4598}
4599inline std::string* DebuggedGraph::unsafe_arena_release_graph_name() {
4600 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebuggedGraph.graph_name)
4601 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4602
4603 return graph_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4604 GetArenaNoVirtual());
4605}
4606inline void DebuggedGraph::unsafe_arena_set_allocated_graph_name(
4607 std::string* graph_name) {
4608 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4609 if (graph_name != nullptr) {
4610
4611 } else {
4612
4613 }
4614 graph_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4615 graph_name, GetArenaNoVirtual());
4616 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebuggedGraph.graph_name)
4617}
4618
4619// repeated string instrumented_ops = 3;
4620inline int DebuggedGraph::instrumented_ops_size() const {
4621 return instrumented_ops_.size();
4622}
4623inline void DebuggedGraph::clear_instrumented_ops() {
4624 instrumented_ops_.Clear();
4625}
4626inline const std::string& DebuggedGraph::instrumented_ops(int index) const {
4627 // @@protoc_insertion_point(field_get:tensorflow.DebuggedGraph.instrumented_ops)
4628 return instrumented_ops_.Get(index);
4629}
4630inline std::string* DebuggedGraph::mutable_instrumented_ops(int index) {
4631 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedGraph.instrumented_ops)
4632 return instrumented_ops_.Mutable(index);
4633}
4634inline void DebuggedGraph::set_instrumented_ops(int index, const std::string& value) {
4635 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.instrumented_ops)
4636 instrumented_ops_.Mutable(index)->assign(value);
4637}
4638inline void DebuggedGraph::set_instrumented_ops(int index, std::string&& value) {
4639 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.instrumented_ops)
4640 instrumented_ops_.Mutable(index)->assign(std::move(value));
4641}
4642inline void DebuggedGraph::set_instrumented_ops(int index, const char* value) {
4643 GOOGLE_DCHECK(value != nullptr);
4644 instrumented_ops_.Mutable(index)->assign(value);
4645 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedGraph.instrumented_ops)
4646}
4647inline void DebuggedGraph::set_instrumented_ops(int index, const char* value, size_t size) {
4648 instrumented_ops_.Mutable(index)->assign(
4649 reinterpret_cast<const char*>(value), size);
4650 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedGraph.instrumented_ops)
4651}
4652inline std::string* DebuggedGraph::add_instrumented_ops() {
4653 // @@protoc_insertion_point(field_add_mutable:tensorflow.DebuggedGraph.instrumented_ops)
4654 return instrumented_ops_.Add();
4655}
4656inline void DebuggedGraph::add_instrumented_ops(const std::string& value) {
4657 instrumented_ops_.Add()->assign(value);
4658 // @@protoc_insertion_point(field_add:tensorflow.DebuggedGraph.instrumented_ops)
4659}
4660inline void DebuggedGraph::add_instrumented_ops(std::string&& value) {
4661 instrumented_ops_.Add(std::move(value));
4662 // @@protoc_insertion_point(field_add:tensorflow.DebuggedGraph.instrumented_ops)
4663}
4664inline void DebuggedGraph::add_instrumented_ops(const char* value) {
4665 GOOGLE_DCHECK(value != nullptr);
4666 instrumented_ops_.Add()->assign(value);
4667 // @@protoc_insertion_point(field_add_char:tensorflow.DebuggedGraph.instrumented_ops)
4668}
4669inline void DebuggedGraph::add_instrumented_ops(const char* value, size_t size) {
4670 instrumented_ops_.Add()->assign(reinterpret_cast<const char*>(value), size);
4671 // @@protoc_insertion_point(field_add_pointer:tensorflow.DebuggedGraph.instrumented_ops)
4672}
4673inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
4674DebuggedGraph::instrumented_ops() const {
4675 // @@protoc_insertion_point(field_list:tensorflow.DebuggedGraph.instrumented_ops)
4676 return instrumented_ops_;
4677}
4678inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
4679DebuggedGraph::mutable_instrumented_ops() {
4680 // @@protoc_insertion_point(field_mutable_list:tensorflow.DebuggedGraph.instrumented_ops)
4681 return &instrumented_ops_;
4682}
4683
4684// bytes original_graph_def = 4;
4685inline void DebuggedGraph::clear_original_graph_def() {
4686 original_graph_def_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4687}
4688inline const std::string& DebuggedGraph::original_graph_def() const {
4689 // @@protoc_insertion_point(field_get:tensorflow.DebuggedGraph.original_graph_def)
4690 return original_graph_def_.Get();
4691}
4692inline void DebuggedGraph::set_original_graph_def(const std::string& value) {
4693
4694 original_graph_def_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4695 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.original_graph_def)
4696}
4697inline void DebuggedGraph::set_original_graph_def(std::string&& value) {
4698
4699 original_graph_def_.Set(
4700 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4701 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebuggedGraph.original_graph_def)
4702}
4703inline void DebuggedGraph::set_original_graph_def(const char* value) {
4704 GOOGLE_DCHECK(value != nullptr);
4705
4706 original_graph_def_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4707 GetArenaNoVirtual());
4708 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedGraph.original_graph_def)
4709}
4710inline void DebuggedGraph::set_original_graph_def(const void* value,
4711 size_t size) {
4712
4713 original_graph_def_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4714 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4715 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedGraph.original_graph_def)
4716}
4717inline std::string* DebuggedGraph::mutable_original_graph_def() {
4718
4719 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedGraph.original_graph_def)
4720 return original_graph_def_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4721}
4722inline std::string* DebuggedGraph::release_original_graph_def() {
4723 // @@protoc_insertion_point(field_release:tensorflow.DebuggedGraph.original_graph_def)
4724
4725 return original_graph_def_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4726}
4727inline void DebuggedGraph::set_allocated_original_graph_def(std::string* original_graph_def) {
4728 if (original_graph_def != nullptr) {
4729
4730 } else {
4731
4732 }
4733 original_graph_def_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), original_graph_def,
4734 GetArenaNoVirtual());
4735 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedGraph.original_graph_def)
4736}
4737inline std::string* DebuggedGraph::unsafe_arena_release_original_graph_def() {
4738 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebuggedGraph.original_graph_def)
4739 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4740
4741 return original_graph_def_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4742 GetArenaNoVirtual());
4743}
4744inline void DebuggedGraph::unsafe_arena_set_allocated_original_graph_def(
4745 std::string* original_graph_def) {
4746 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4747 if (original_graph_def != nullptr) {
4748
4749 } else {
4750
4751 }
4752 original_graph_def_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4753 original_graph_def, GetArenaNoVirtual());
4754 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebuggedGraph.original_graph_def)
4755}
4756
4757// bytes instrumented_graph_def = 5;
4758inline void DebuggedGraph::clear_instrumented_graph_def() {
4759 instrumented_graph_def_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4760}
4761inline const std::string& DebuggedGraph::instrumented_graph_def() const {
4762 // @@protoc_insertion_point(field_get:tensorflow.DebuggedGraph.instrumented_graph_def)
4763 return instrumented_graph_def_.Get();
4764}
4765inline void DebuggedGraph::set_instrumented_graph_def(const std::string& value) {
4766
4767 instrumented_graph_def_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4768 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.instrumented_graph_def)
4769}
4770inline void DebuggedGraph::set_instrumented_graph_def(std::string&& value) {
4771
4772 instrumented_graph_def_.Set(
4773 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4774 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebuggedGraph.instrumented_graph_def)
4775}
4776inline void DebuggedGraph::set_instrumented_graph_def(const char* value) {
4777 GOOGLE_DCHECK(value != nullptr);
4778
4779 instrumented_graph_def_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4780 GetArenaNoVirtual());
4781 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedGraph.instrumented_graph_def)
4782}
4783inline void DebuggedGraph::set_instrumented_graph_def(const void* value,
4784 size_t size) {
4785
4786 instrumented_graph_def_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4787 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4788 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedGraph.instrumented_graph_def)
4789}
4790inline std::string* DebuggedGraph::mutable_instrumented_graph_def() {
4791
4792 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedGraph.instrumented_graph_def)
4793 return instrumented_graph_def_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4794}
4795inline std::string* DebuggedGraph::release_instrumented_graph_def() {
4796 // @@protoc_insertion_point(field_release:tensorflow.DebuggedGraph.instrumented_graph_def)
4797
4798 return instrumented_graph_def_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4799}
4800inline void DebuggedGraph::set_allocated_instrumented_graph_def(std::string* instrumented_graph_def) {
4801 if (instrumented_graph_def != nullptr) {
4802
4803 } else {
4804
4805 }
4806 instrumented_graph_def_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), instrumented_graph_def,
4807 GetArenaNoVirtual());
4808 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedGraph.instrumented_graph_def)
4809}
4810inline std::string* DebuggedGraph::unsafe_arena_release_instrumented_graph_def() {
4811 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebuggedGraph.instrumented_graph_def)
4812 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4813
4814 return instrumented_graph_def_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4815 GetArenaNoVirtual());
4816}
4817inline void DebuggedGraph::unsafe_arena_set_allocated_instrumented_graph_def(
4818 std::string* instrumented_graph_def) {
4819 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4820 if (instrumented_graph_def != nullptr) {
4821
4822 } else {
4823
4824 }
4825 instrumented_graph_def_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4826 instrumented_graph_def, GetArenaNoVirtual());
4827 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebuggedGraph.instrumented_graph_def)
4828}
4829
4830// string outer_context_id = 6;
4831inline void DebuggedGraph::clear_outer_context_id() {
4832 outer_context_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4833}
4834inline const std::string& DebuggedGraph::outer_context_id() const {
4835 // @@protoc_insertion_point(field_get:tensorflow.DebuggedGraph.outer_context_id)
4836 return outer_context_id_.Get();
4837}
4838inline void DebuggedGraph::set_outer_context_id(const std::string& value) {
4839
4840 outer_context_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4841 // @@protoc_insertion_point(field_set:tensorflow.DebuggedGraph.outer_context_id)
4842}
4843inline void DebuggedGraph::set_outer_context_id(std::string&& value) {
4844
4845 outer_context_id_.Set(
4846 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4847 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebuggedGraph.outer_context_id)
4848}
4849inline void DebuggedGraph::set_outer_context_id(const char* value) {
4850 GOOGLE_DCHECK(value != nullptr);
4851
4852 outer_context_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4853 GetArenaNoVirtual());
4854 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedGraph.outer_context_id)
4855}
4856inline void DebuggedGraph::set_outer_context_id(const char* value,
4857 size_t size) {
4858
4859 outer_context_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4860 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4861 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedGraph.outer_context_id)
4862}
4863inline std::string* DebuggedGraph::mutable_outer_context_id() {
4864
4865 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedGraph.outer_context_id)
4866 return outer_context_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4867}
4868inline std::string* DebuggedGraph::release_outer_context_id() {
4869 // @@protoc_insertion_point(field_release:tensorflow.DebuggedGraph.outer_context_id)
4870
4871 return outer_context_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4872}
4873inline void DebuggedGraph::set_allocated_outer_context_id(std::string* outer_context_id) {
4874 if (outer_context_id != nullptr) {
4875
4876 } else {
4877
4878 }
4879 outer_context_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), outer_context_id,
4880 GetArenaNoVirtual());
4881 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedGraph.outer_context_id)
4882}
4883inline std::string* DebuggedGraph::unsafe_arena_release_outer_context_id() {
4884 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebuggedGraph.outer_context_id)
4885 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4886
4887 return outer_context_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4888 GetArenaNoVirtual());
4889}
4890inline void DebuggedGraph::unsafe_arena_set_allocated_outer_context_id(
4891 std::string* outer_context_id) {
4892 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4893 if (outer_context_id != nullptr) {
4894
4895 } else {
4896
4897 }
4898 outer_context_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4899 outer_context_id, GetArenaNoVirtual());
4900 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebuggedGraph.outer_context_id)
4901}
4902
4903// -------------------------------------------------------------------
4904
4905// DebuggedDevice
4906
4907// string device_name = 1;
4908inline void DebuggedDevice::clear_device_name() {
4909 device_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4910}
4911inline const std::string& DebuggedDevice::device_name() const {
4912 // @@protoc_insertion_point(field_get:tensorflow.DebuggedDevice.device_name)
4913 return device_name_.Get();
4914}
4915inline void DebuggedDevice::set_device_name(const std::string& value) {
4916
4917 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
4918 // @@protoc_insertion_point(field_set:tensorflow.DebuggedDevice.device_name)
4919}
4920inline void DebuggedDevice::set_device_name(std::string&& value) {
4921
4922 device_name_.Set(
4923 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
4924 // @@protoc_insertion_point(field_set_rvalue:tensorflow.DebuggedDevice.device_name)
4925}
4926inline void DebuggedDevice::set_device_name(const char* value) {
4927 GOOGLE_DCHECK(value != nullptr);
4928
4929 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
4930 GetArenaNoVirtual());
4931 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedDevice.device_name)
4932}
4933inline void DebuggedDevice::set_device_name(const char* value,
4934 size_t size) {
4935
4936 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
4937 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
4938 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedDevice.device_name)
4939}
4940inline std::string* DebuggedDevice::mutable_device_name() {
4941
4942 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedDevice.device_name)
4943 return device_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4944}
4945inline std::string* DebuggedDevice::release_device_name() {
4946 // @@protoc_insertion_point(field_release:tensorflow.DebuggedDevice.device_name)
4947
4948 return device_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
4949}
4950inline void DebuggedDevice::set_allocated_device_name(std::string* device_name) {
4951 if (device_name != nullptr) {
4952
4953 } else {
4954
4955 }
4956 device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_name,
4957 GetArenaNoVirtual());
4958 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedDevice.device_name)
4959}
4960inline std::string* DebuggedDevice::unsafe_arena_release_device_name() {
4961 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.DebuggedDevice.device_name)
4962 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4963
4964 return device_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4965 GetArenaNoVirtual());
4966}
4967inline void DebuggedDevice::unsafe_arena_set_allocated_device_name(
4968 std::string* device_name) {
4969 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
4970 if (device_name != nullptr) {
4971
4972 } else {
4973
4974 }
4975 device_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
4976 device_name, GetArenaNoVirtual());
4977 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.DebuggedDevice.device_name)
4978}
4979
4980// int32 device_id = 2;
4981inline void DebuggedDevice::clear_device_id() {
4982 device_id_ = 0;
4983}
4984inline ::PROTOBUF_NAMESPACE_ID::int32 DebuggedDevice::device_id() const {
4985 // @@protoc_insertion_point(field_get:tensorflow.DebuggedDevice.device_id)
4986 return device_id_;
4987}
4988inline void DebuggedDevice::set_device_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
4989
4990 device_id_ = value;
4991 // @@protoc_insertion_point(field_set:tensorflow.DebuggedDevice.device_id)
4992}
4993
4994// -------------------------------------------------------------------
4995
4996// Execution
4997
4998// string op_type = 1;
4999inline void Execution::clear_op_type() {
5000 op_type_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5001}
5002inline const std::string& Execution::op_type() const {
5003 // @@protoc_insertion_point(field_get:tensorflow.Execution.op_type)
5004 return op_type_.Get();
5005}
5006inline void Execution::set_op_type(const std::string& value) {
5007
5008 op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5009 // @@protoc_insertion_point(field_set:tensorflow.Execution.op_type)
5010}
5011inline void Execution::set_op_type(std::string&& value) {
5012
5013 op_type_.Set(
5014 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5015 // @@protoc_insertion_point(field_set_rvalue:tensorflow.Execution.op_type)
5016}
5017inline void Execution::set_op_type(const char* value) {
5018 GOOGLE_DCHECK(value != nullptr);
5019
5020 op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5021 GetArenaNoVirtual());
5022 // @@protoc_insertion_point(field_set_char:tensorflow.Execution.op_type)
5023}
5024inline void Execution::set_op_type(const char* value,
5025 size_t size) {
5026
5027 op_type_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5028 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5029 // @@protoc_insertion_point(field_set_pointer:tensorflow.Execution.op_type)
5030}
5031inline std::string* Execution::mutable_op_type() {
5032
5033 // @@protoc_insertion_point(field_mutable:tensorflow.Execution.op_type)
5034 return op_type_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5035}
5036inline std::string* Execution::release_op_type() {
5037 // @@protoc_insertion_point(field_release:tensorflow.Execution.op_type)
5038
5039 return op_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5040}
5041inline void Execution::set_allocated_op_type(std::string* op_type) {
5042 if (op_type != nullptr) {
5043
5044 } else {
5045
5046 }
5047 op_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_type,
5048 GetArenaNoVirtual());
5049 // @@protoc_insertion_point(field_set_allocated:tensorflow.Execution.op_type)
5050}
5051inline std::string* Execution::unsafe_arena_release_op_type() {
5052 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Execution.op_type)
5053 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5054
5055 return op_type_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5056 GetArenaNoVirtual());
5057}
5058inline void Execution::unsafe_arena_set_allocated_op_type(
5059 std::string* op_type) {
5060 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5061 if (op_type != nullptr) {
5062
5063 } else {
5064
5065 }
5066 op_type_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5067 op_type, GetArenaNoVirtual());
5068 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Execution.op_type)
5069}
5070
5071// int32 num_outputs = 2;
5072inline void Execution::clear_num_outputs() {
5073 num_outputs_ = 0;
5074}
5075inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::num_outputs() const {
5076 // @@protoc_insertion_point(field_get:tensorflow.Execution.num_outputs)
5077 return num_outputs_;
5078}
5079inline void Execution::set_num_outputs(::PROTOBUF_NAMESPACE_ID::int32 value) {
5080
5081 num_outputs_ = value;
5082 // @@protoc_insertion_point(field_set:tensorflow.Execution.num_outputs)
5083}
5084
5085// string graph_id = 3;
5086inline void Execution::clear_graph_id() {
5087 graph_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5088}
5089inline const std::string& Execution::graph_id() const {
5090 // @@protoc_insertion_point(field_get:tensorflow.Execution.graph_id)
5091 return graph_id_.Get();
5092}
5093inline void Execution::set_graph_id(const std::string& value) {
5094
5095 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5096 // @@protoc_insertion_point(field_set:tensorflow.Execution.graph_id)
5097}
5098inline void Execution::set_graph_id(std::string&& value) {
5099
5100 graph_id_.Set(
5101 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5102 // @@protoc_insertion_point(field_set_rvalue:tensorflow.Execution.graph_id)
5103}
5104inline void Execution::set_graph_id(const char* value) {
5105 GOOGLE_DCHECK(value != nullptr);
5106
5107 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5108 GetArenaNoVirtual());
5109 // @@protoc_insertion_point(field_set_char:tensorflow.Execution.graph_id)
5110}
5111inline void Execution::set_graph_id(const char* value,
5112 size_t size) {
5113
5114 graph_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5115 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5116 // @@protoc_insertion_point(field_set_pointer:tensorflow.Execution.graph_id)
5117}
5118inline std::string* Execution::mutable_graph_id() {
5119
5120 // @@protoc_insertion_point(field_mutable:tensorflow.Execution.graph_id)
5121 return graph_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5122}
5123inline std::string* Execution::release_graph_id() {
5124 // @@protoc_insertion_point(field_release:tensorflow.Execution.graph_id)
5125
5126 return graph_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5127}
5128inline void Execution::set_allocated_graph_id(std::string* graph_id) {
5129 if (graph_id != nullptr) {
5130
5131 } else {
5132
5133 }
5134 graph_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), graph_id,
5135 GetArenaNoVirtual());
5136 // @@protoc_insertion_point(field_set_allocated:tensorflow.Execution.graph_id)
5137}
5138inline std::string* Execution::unsafe_arena_release_graph_id() {
5139 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Execution.graph_id)
5140 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5141
5142 return graph_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5143 GetArenaNoVirtual());
5144}
5145inline void Execution::unsafe_arena_set_allocated_graph_id(
5146 std::string* graph_id) {
5147 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5148 if (graph_id != nullptr) {
5149
5150 } else {
5151
5152 }
5153 graph_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5154 graph_id, GetArenaNoVirtual());
5155 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.Execution.graph_id)
5156}
5157
5158// repeated int64 input_tensor_ids = 4;
5159inline int Execution::input_tensor_ids_size() const {
5160 return input_tensor_ids_.size();
5161}
5162inline void Execution::clear_input_tensor_ids() {
5163 input_tensor_ids_.Clear();
5164}
5165inline ::PROTOBUF_NAMESPACE_ID::int64 Execution::input_tensor_ids(int index) const {
5166 // @@protoc_insertion_point(field_get:tensorflow.Execution.input_tensor_ids)
5167 return input_tensor_ids_.Get(index);
5168}
5169inline void Execution::set_input_tensor_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
5170 input_tensor_ids_.Set(index, value);
5171 // @@protoc_insertion_point(field_set:tensorflow.Execution.input_tensor_ids)
5172}
5173inline void Execution::add_input_tensor_ids(::PROTOBUF_NAMESPACE_ID::int64 value) {
5174 input_tensor_ids_.Add(value);
5175 // @@protoc_insertion_point(field_add:tensorflow.Execution.input_tensor_ids)
5176}
5177inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
5178Execution::input_tensor_ids() const {
5179 // @@protoc_insertion_point(field_list:tensorflow.Execution.input_tensor_ids)
5180 return input_tensor_ids_;
5181}
5182inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
5183Execution::mutable_input_tensor_ids() {
5184 // @@protoc_insertion_point(field_mutable_list:tensorflow.Execution.input_tensor_ids)
5185 return &input_tensor_ids_;
5186}
5187
5188// repeated int64 output_tensor_ids = 5;
5189inline int Execution::output_tensor_ids_size() const {
5190 return output_tensor_ids_.size();
5191}
5192inline void Execution::clear_output_tensor_ids() {
5193 output_tensor_ids_.Clear();
5194}
5195inline ::PROTOBUF_NAMESPACE_ID::int64 Execution::output_tensor_ids(int index) const {
5196 // @@protoc_insertion_point(field_get:tensorflow.Execution.output_tensor_ids)
5197 return output_tensor_ids_.Get(index);
5198}
5199inline void Execution::set_output_tensor_ids(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
5200 output_tensor_ids_.Set(index, value);
5201 // @@protoc_insertion_point(field_set:tensorflow.Execution.output_tensor_ids)
5202}
5203inline void Execution::add_output_tensor_ids(::PROTOBUF_NAMESPACE_ID::int64 value) {
5204 output_tensor_ids_.Add(value);
5205 // @@protoc_insertion_point(field_add:tensorflow.Execution.output_tensor_ids)
5206}
5207inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
5208Execution::output_tensor_ids() const {
5209 // @@protoc_insertion_point(field_list:tensorflow.Execution.output_tensor_ids)
5210 return output_tensor_ids_;
5211}
5212inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
5213Execution::mutable_output_tensor_ids() {
5214 // @@protoc_insertion_point(field_mutable_list:tensorflow.Execution.output_tensor_ids)
5215 return &output_tensor_ids_;
5216}
5217
5218// .tensorflow.TensorDebugMode tensor_debug_mode = 6;
5219inline void Execution::clear_tensor_debug_mode() {
5220 tensor_debug_mode_ = 0;
5221}
5222inline ::tensorflow::TensorDebugMode Execution::tensor_debug_mode() const {
5223 // @@protoc_insertion_point(field_get:tensorflow.Execution.tensor_debug_mode)
5224 return static_cast< ::tensorflow::TensorDebugMode >(tensor_debug_mode_);
5225}
5226inline void Execution::set_tensor_debug_mode(::tensorflow::TensorDebugMode value) {
5227
5228 tensor_debug_mode_ = value;
5229 // @@protoc_insertion_point(field_set:tensorflow.Execution.tensor_debug_mode)
5230}
5231
5232// repeated .tensorflow.TensorProto tensor_protos = 7;
5233inline int Execution::tensor_protos_size() const {
5234 return tensor_protos_.size();
5235}
5236inline ::tensorflow::TensorProto* Execution::mutable_tensor_protos(int index) {
5237 // @@protoc_insertion_point(field_mutable:tensorflow.Execution.tensor_protos)
5238 return tensor_protos_.Mutable(index);
5239}
5240inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >*
5241Execution::mutable_tensor_protos() {
5242 // @@protoc_insertion_point(field_mutable_list:tensorflow.Execution.tensor_protos)
5243 return &tensor_protos_;
5244}
5245inline const ::tensorflow::TensorProto& Execution::tensor_protos(int index) const {
5246 // @@protoc_insertion_point(field_get:tensorflow.Execution.tensor_protos)
5247 return tensor_protos_.Get(index);
5248}
5249inline ::tensorflow::TensorProto* Execution::add_tensor_protos() {
5250 // @@protoc_insertion_point(field_add:tensorflow.Execution.tensor_protos)
5251 return tensor_protos_.Add();
5252}
5253inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::TensorProto >&
5254Execution::tensor_protos() const {
5255 // @@protoc_insertion_point(field_list:tensorflow.Execution.tensor_protos)
5256 return tensor_protos_;
5257}
5258
5259// .tensorflow.CodeLocation code_location = 8;
5260inline bool Execution::has_code_location() const {
5261 return this != internal_default_instance() && code_location_ != nullptr;
5262}
5263inline void Execution::clear_code_location() {
5264 if (GetArenaNoVirtual() == nullptr && code_location_ != nullptr) {
5265 delete code_location_;
5266 }
5267 code_location_ = nullptr;
5268}
5269inline const ::tensorflow::CodeLocation& Execution::code_location() const {
5270 const ::tensorflow::CodeLocation* p = code_location_;
5271 // @@protoc_insertion_point(field_get:tensorflow.Execution.code_location)
5272 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::CodeLocation*>(
5273 &::tensorflow::_CodeLocation_default_instance_);
5274}
5275inline ::tensorflow::CodeLocation* Execution::release_code_location() {
5276 // @@protoc_insertion_point(field_release:tensorflow.Execution.code_location)
5277
5278 ::tensorflow::CodeLocation* temp = code_location_;
5279 if (GetArenaNoVirtual() != nullptr) {
5280 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5281 }
5282 code_location_ = nullptr;
5283 return temp;
5284}
5285inline ::tensorflow::CodeLocation* Execution::unsafe_arena_release_code_location() {
5286 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.Execution.code_location)
5287
5288 ::tensorflow::CodeLocation* temp = code_location_;
5289 code_location_ = nullptr;
5290 return temp;
5291}
5292inline ::tensorflow::CodeLocation* Execution::mutable_code_location() {
5293
5294 if (code_location_ == nullptr) {
5295 auto* p = CreateMaybeMessage<::tensorflow::CodeLocation>(GetArenaNoVirtual());
5296 code_location_ = p;
5297 }
5298 // @@protoc_insertion_point(field_mutable:tensorflow.Execution.code_location)
5299 return code_location_;
5300}
5301inline void Execution::set_allocated_code_location(::tensorflow::CodeLocation* code_location) {
5302 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5303 if (message_arena == nullptr) {
5304 delete code_location_;
5305 }
5306 if (code_location) {
5307 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5308 ::PROTOBUF_NAMESPACE_ID::Arena::GetArena(code_location);
5309 if (message_arena != submessage_arena) {
5310 code_location = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5311 message_arena, code_location, submessage_arena);
5312 }
5313
5314 } else {
5315
5316 }
5317 code_location_ = code_location;
5318 // @@protoc_insertion_point(field_set_allocated:tensorflow.Execution.code_location)
5319}
5320
5321// repeated int32 output_tensor_device_ids = 9;
5322inline int Execution::output_tensor_device_ids_size() const {
5323 return output_tensor_device_ids_.size();
5324}
5325inline void Execution::clear_output_tensor_device_ids() {
5326 output_tensor_device_ids_.Clear();
5327}
5328inline ::PROTOBUF_NAMESPACE_ID::int32 Execution::output_tensor_device_ids(int index) const {
5329 // @@protoc_insertion_point(field_get:tensorflow.Execution.output_tensor_device_ids)
5330 return output_tensor_device_ids_.Get(index);
5331}
5332inline void Execution::set_output_tensor_device_ids(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
5333 output_tensor_device_ids_.Set(index, value);
5334 // @@protoc_insertion_point(field_set:tensorflow.Execution.output_tensor_device_ids)
5335}
5336inline void Execution::add_output_tensor_device_ids(::PROTOBUF_NAMESPACE_ID::int32 value) {
5337 output_tensor_device_ids_.Add(value);
5338 // @@protoc_insertion_point(field_add:tensorflow.Execution.output_tensor_device_ids)
5339}
5340inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
5341Execution::output_tensor_device_ids() const {
5342 // @@protoc_insertion_point(field_list:tensorflow.Execution.output_tensor_device_ids)
5343 return output_tensor_device_ids_;
5344}
5345inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
5346Execution::mutable_output_tensor_device_ids() {
5347 // @@protoc_insertion_point(field_mutable_list:tensorflow.Execution.output_tensor_device_ids)
5348 return &output_tensor_device_ids_;
5349}
5350
5351// -------------------------------------------------------------------
5352
5353// GraphExecutionTrace
5354
5355// string tfdbg_context_id = 1;
5356inline void GraphExecutionTrace::clear_tfdbg_context_id() {
5357 tfdbg_context_id_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5358}
5359inline const std::string& GraphExecutionTrace::tfdbg_context_id() const {
5360 // @@protoc_insertion_point(field_get:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5361 return tfdbg_context_id_.Get();
5362}
5363inline void GraphExecutionTrace::set_tfdbg_context_id(const std::string& value) {
5364
5365 tfdbg_context_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5366 // @@protoc_insertion_point(field_set:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5367}
5368inline void GraphExecutionTrace::set_tfdbg_context_id(std::string&& value) {
5369
5370 tfdbg_context_id_.Set(
5371 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5372 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5373}
5374inline void GraphExecutionTrace::set_tfdbg_context_id(const char* value) {
5375 GOOGLE_DCHECK(value != nullptr);
5376
5377 tfdbg_context_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5378 GetArenaNoVirtual());
5379 // @@protoc_insertion_point(field_set_char:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5380}
5381inline void GraphExecutionTrace::set_tfdbg_context_id(const char* value,
5382 size_t size) {
5383
5384 tfdbg_context_id_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5385 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5386 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5387}
5388inline std::string* GraphExecutionTrace::mutable_tfdbg_context_id() {
5389
5390 // @@protoc_insertion_point(field_mutable:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5391 return tfdbg_context_id_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5392}
5393inline std::string* GraphExecutionTrace::release_tfdbg_context_id() {
5394 // @@protoc_insertion_point(field_release:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5395
5396 return tfdbg_context_id_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5397}
5398inline void GraphExecutionTrace::set_allocated_tfdbg_context_id(std::string* tfdbg_context_id) {
5399 if (tfdbg_context_id != nullptr) {
5400
5401 } else {
5402
5403 }
5404 tfdbg_context_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), tfdbg_context_id,
5405 GetArenaNoVirtual());
5406 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5407}
5408inline std::string* GraphExecutionTrace::unsafe_arena_release_tfdbg_context_id() {
5409 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5410 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5411
5412 return tfdbg_context_id_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5413 GetArenaNoVirtual());
5414}
5415inline void GraphExecutionTrace::unsafe_arena_set_allocated_tfdbg_context_id(
5416 std::string* tfdbg_context_id) {
5417 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5418 if (tfdbg_context_id != nullptr) {
5419
5420 } else {
5421
5422 }
5423 tfdbg_context_id_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5424 tfdbg_context_id, GetArenaNoVirtual());
5425 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphExecutionTrace.tfdbg_context_id)
5426}
5427
5428// string op_name = 2;
5429inline void GraphExecutionTrace::clear_op_name() {
5430 op_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5431}
5432inline const std::string& GraphExecutionTrace::op_name() const {
5433 // @@protoc_insertion_point(field_get:tensorflow.GraphExecutionTrace.op_name)
5434 return op_name_.Get();
5435}
5436inline void GraphExecutionTrace::set_op_name(const std::string& value) {
5437
5438 op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5439 // @@protoc_insertion_point(field_set:tensorflow.GraphExecutionTrace.op_name)
5440}
5441inline void GraphExecutionTrace::set_op_name(std::string&& value) {
5442
5443 op_name_.Set(
5444 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5445 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphExecutionTrace.op_name)
5446}
5447inline void GraphExecutionTrace::set_op_name(const char* value) {
5448 GOOGLE_DCHECK(value != nullptr);
5449
5450 op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5451 GetArenaNoVirtual());
5452 // @@protoc_insertion_point(field_set_char:tensorflow.GraphExecutionTrace.op_name)
5453}
5454inline void GraphExecutionTrace::set_op_name(const char* value,
5455 size_t size) {
5456
5457 op_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5458 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5459 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphExecutionTrace.op_name)
5460}
5461inline std::string* GraphExecutionTrace::mutable_op_name() {
5462
5463 // @@protoc_insertion_point(field_mutable:tensorflow.GraphExecutionTrace.op_name)
5464 return op_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5465}
5466inline std::string* GraphExecutionTrace::release_op_name() {
5467 // @@protoc_insertion_point(field_release:tensorflow.GraphExecutionTrace.op_name)
5468
5469 return op_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5470}
5471inline void GraphExecutionTrace::set_allocated_op_name(std::string* op_name) {
5472 if (op_name != nullptr) {
5473
5474 } else {
5475
5476 }
5477 op_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), op_name,
5478 GetArenaNoVirtual());
5479 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphExecutionTrace.op_name)
5480}
5481inline std::string* GraphExecutionTrace::unsafe_arena_release_op_name() {
5482 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphExecutionTrace.op_name)
5483 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5484
5485 return op_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5486 GetArenaNoVirtual());
5487}
5488inline void GraphExecutionTrace::unsafe_arena_set_allocated_op_name(
5489 std::string* op_name) {
5490 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5491 if (op_name != nullptr) {
5492
5493 } else {
5494
5495 }
5496 op_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5497 op_name, GetArenaNoVirtual());
5498 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphExecutionTrace.op_name)
5499}
5500
5501// int32 output_slot = 3;
5502inline void GraphExecutionTrace::clear_output_slot() {
5503 output_slot_ = 0;
5504}
5505inline ::PROTOBUF_NAMESPACE_ID::int32 GraphExecutionTrace::output_slot() const {
5506 // @@protoc_insertion_point(field_get:tensorflow.GraphExecutionTrace.output_slot)
5507 return output_slot_;
5508}
5509inline void GraphExecutionTrace::set_output_slot(::PROTOBUF_NAMESPACE_ID::int32 value) {
5510
5511 output_slot_ = value;
5512 // @@protoc_insertion_point(field_set:tensorflow.GraphExecutionTrace.output_slot)
5513}
5514
5515// .tensorflow.TensorDebugMode tensor_debug_mode = 4;
5516inline void GraphExecutionTrace::clear_tensor_debug_mode() {
5517 tensor_debug_mode_ = 0;
5518}
5519inline ::tensorflow::TensorDebugMode GraphExecutionTrace::tensor_debug_mode() const {
5520 // @@protoc_insertion_point(field_get:tensorflow.GraphExecutionTrace.tensor_debug_mode)
5521 return static_cast< ::tensorflow::TensorDebugMode >(tensor_debug_mode_);
5522}
5523inline void GraphExecutionTrace::set_tensor_debug_mode(::tensorflow::TensorDebugMode value) {
5524
5525 tensor_debug_mode_ = value;
5526 // @@protoc_insertion_point(field_set:tensorflow.GraphExecutionTrace.tensor_debug_mode)
5527}
5528
5529// .tensorflow.TensorProto tensor_proto = 5;
5530inline bool GraphExecutionTrace::has_tensor_proto() const {
5531 return this != internal_default_instance() && tensor_proto_ != nullptr;
5532}
5533inline const ::tensorflow::TensorProto& GraphExecutionTrace::tensor_proto() const {
5534 const ::tensorflow::TensorProto* p = tensor_proto_;
5535 // @@protoc_insertion_point(field_get:tensorflow.GraphExecutionTrace.tensor_proto)
5536 return p != nullptr ? *p : *reinterpret_cast<const ::tensorflow::TensorProto*>(
5537 &::tensorflow::_TensorProto_default_instance_);
5538}
5539inline ::tensorflow::TensorProto* GraphExecutionTrace::release_tensor_proto() {
5540 // @@protoc_insertion_point(field_release:tensorflow.GraphExecutionTrace.tensor_proto)
5541
5542 ::tensorflow::TensorProto* temp = tensor_proto_;
5543 if (GetArenaNoVirtual() != nullptr) {
5544 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
5545 }
5546 tensor_proto_ = nullptr;
5547 return temp;
5548}
5549inline ::tensorflow::TensorProto* GraphExecutionTrace::unsafe_arena_release_tensor_proto() {
5550 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphExecutionTrace.tensor_proto)
5551
5552 ::tensorflow::TensorProto* temp = tensor_proto_;
5553 tensor_proto_ = nullptr;
5554 return temp;
5555}
5556inline ::tensorflow::TensorProto* GraphExecutionTrace::mutable_tensor_proto() {
5557
5558 if (tensor_proto_ == nullptr) {
5559 auto* p = CreateMaybeMessage<::tensorflow::TensorProto>(GetArenaNoVirtual());
5560 tensor_proto_ = p;
5561 }
5562 // @@protoc_insertion_point(field_mutable:tensorflow.GraphExecutionTrace.tensor_proto)
5563 return tensor_proto_;
5564}
5565inline void GraphExecutionTrace::set_allocated_tensor_proto(::tensorflow::TensorProto* tensor_proto) {
5566 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
5567 if (message_arena == nullptr) {
5568 delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_proto_);
5569 }
5570 if (tensor_proto) {
5571 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
5572 reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(tensor_proto)->GetArena();
5573 if (message_arena != submessage_arena) {
5574 tensor_proto = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
5575 message_arena, tensor_proto, submessage_arena);
5576 }
5577
5578 } else {
5579
5580 }
5581 tensor_proto_ = tensor_proto;
5582 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphExecutionTrace.tensor_proto)
5583}
5584
5585// string device_name = 6;
5586inline void GraphExecutionTrace::clear_device_name() {
5587 device_name_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5588}
5589inline const std::string& GraphExecutionTrace::device_name() const {
5590 // @@protoc_insertion_point(field_get:tensorflow.GraphExecutionTrace.device_name)
5591 return device_name_.Get();
5592}
5593inline void GraphExecutionTrace::set_device_name(const std::string& value) {
5594
5595 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
5596 // @@protoc_insertion_point(field_set:tensorflow.GraphExecutionTrace.device_name)
5597}
5598inline void GraphExecutionTrace::set_device_name(std::string&& value) {
5599
5600 device_name_.Set(
5601 &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
5602 // @@protoc_insertion_point(field_set_rvalue:tensorflow.GraphExecutionTrace.device_name)
5603}
5604inline void GraphExecutionTrace::set_device_name(const char* value) {
5605 GOOGLE_DCHECK(value != nullptr);
5606
5607 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
5608 GetArenaNoVirtual());
5609 // @@protoc_insertion_point(field_set_char:tensorflow.GraphExecutionTrace.device_name)
5610}
5611inline void GraphExecutionTrace::set_device_name(const char* value,
5612 size_t size) {
5613
5614 device_name_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
5615 reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
5616 // @@protoc_insertion_point(field_set_pointer:tensorflow.GraphExecutionTrace.device_name)
5617}
5618inline std::string* GraphExecutionTrace::mutable_device_name() {
5619
5620 // @@protoc_insertion_point(field_mutable:tensorflow.GraphExecutionTrace.device_name)
5621 return device_name_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5622}
5623inline std::string* GraphExecutionTrace::release_device_name() {
5624 // @@protoc_insertion_point(field_release:tensorflow.GraphExecutionTrace.device_name)
5625
5626 return device_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
5627}
5628inline void GraphExecutionTrace::set_allocated_device_name(std::string* device_name) {
5629 if (device_name != nullptr) {
5630
5631 } else {
5632
5633 }
5634 device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_name,
5635 GetArenaNoVirtual());
5636 // @@protoc_insertion_point(field_set_allocated:tensorflow.GraphExecutionTrace.device_name)
5637}
5638inline std::string* GraphExecutionTrace::unsafe_arena_release_device_name() {
5639 // @@protoc_insertion_point(field_unsafe_arena_release:tensorflow.GraphExecutionTrace.device_name)
5640 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5641
5642 return device_name_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5643 GetArenaNoVirtual());
5644}
5645inline void GraphExecutionTrace::unsafe_arena_set_allocated_device_name(
5646 std::string* device_name) {
5647 GOOGLE_DCHECK(GetArenaNoVirtual() != nullptr);
5648 if (device_name != nullptr) {
5649
5650 } else {
5651
5652 }
5653 device_name_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
5654 device_name, GetArenaNoVirtual());
5655 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:tensorflow.GraphExecutionTrace.device_name)
5656}
5657
5658#ifdef __GNUC__
5659 #pragma GCC diagnostic pop
5660#endif // __GNUC__
5661// -------------------------------------------------------------------
5662
5663// -------------------------------------------------------------------
5664
5665// -------------------------------------------------------------------
5666
5667// -------------------------------------------------------------------
5668
5669// -------------------------------------------------------------------
5670
5671// -------------------------------------------------------------------
5672
5673// -------------------------------------------------------------------
5674
5675// -------------------------------------------------------------------
5676
5677// -------------------------------------------------------------------
5678
5679
5680// @@protoc_insertion_point(namespace_scope)
5681
5682} // namespace tensorflow
5683
5684PROTOBUF_NAMESPACE_OPEN
5685
5686template <> struct is_proto_enum< ::tensorflow::TensorDebugMode> : ::std::true_type {};
5687template <>
5688inline const EnumDescriptor* GetEnumDescriptor< ::tensorflow::TensorDebugMode>() {
5689 return ::tensorflow::TensorDebugMode_descriptor();
5690}
5691
5692PROTOBUF_NAMESPACE_CLOSE
5693
5694// @@protoc_insertion_point(global_scope)
5695
5696#include <google/protobuf/port_undef.inc>
5697#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdebug_5fevent_2eproto
5698