1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/debug.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 // @@protoc_insertion_point(includes)
33 #include <google/protobuf/port_def.inc>
34 #define PROTOBUF_INTERNAL_EXPORT_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto
35 PROTOBUF_NAMESPACE_OPEN
36 namespace internal {
37 class AnyMetadata;
38 } // namespace internal
39 PROTOBUF_NAMESPACE_CLOSE
40
41 // Internal implementation detail -- do not use these members.
42 struct TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto {
43 static const ::uint32_t offsets[];
44 };
45 namespace tensorflow {
46 class DebugOptions;
47 struct DebugOptionsDefaultTypeInternal;
48 extern DebugOptionsDefaultTypeInternal _DebugOptions_default_instance_;
49 class DebugTensorWatch;
50 struct DebugTensorWatchDefaultTypeInternal;
51 extern DebugTensorWatchDefaultTypeInternal _DebugTensorWatch_default_instance_;
52 class DebuggedSourceFile;
53 struct DebuggedSourceFileDefaultTypeInternal;
54 extern DebuggedSourceFileDefaultTypeInternal _DebuggedSourceFile_default_instance_;
55 class DebuggedSourceFiles;
56 struct DebuggedSourceFilesDefaultTypeInternal;
57 extern DebuggedSourceFilesDefaultTypeInternal _DebuggedSourceFiles_default_instance_;
58 } // namespace tensorflow
59 PROTOBUF_NAMESPACE_OPEN
60 template<> ::tensorflow::DebugOptions* Arena::CreateMaybeMessage<::tensorflow::DebugOptions>(Arena*);
61 template<> ::tensorflow::DebugTensorWatch* Arena::CreateMaybeMessage<::tensorflow::DebugTensorWatch>(Arena*);
62 template<> ::tensorflow::DebuggedSourceFile* Arena::CreateMaybeMessage<::tensorflow::DebuggedSourceFile>(Arena*);
63 template<> ::tensorflow::DebuggedSourceFiles* Arena::CreateMaybeMessage<::tensorflow::DebuggedSourceFiles>(Arena*);
64 PROTOBUF_NAMESPACE_CLOSE
65 namespace tensorflow {
66
67 // ===================================================================
68
69 class DebugTensorWatch final :
70 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DebugTensorWatch) */ {
71 public:
DebugTensorWatch()72 inline DebugTensorWatch() : DebugTensorWatch(nullptr) {}
73 ~DebugTensorWatch() override;
74 explicit PROTOBUF_CONSTEXPR DebugTensorWatch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
75
76 DebugTensorWatch(const DebugTensorWatch& from);
DebugTensorWatch(DebugTensorWatch && from)77 DebugTensorWatch(DebugTensorWatch&& from) noexcept
78 : DebugTensorWatch() {
79 *this = ::std::move(from);
80 }
81
82 inline DebugTensorWatch& operator=(const DebugTensorWatch& from) {
83 if (this == &from) return *this;
84 CopyFrom(from);
85 return *this;
86 }
87 inline DebugTensorWatch& operator=(DebugTensorWatch&& from) noexcept {
88 if (this == &from) return *this;
89 if (GetOwningArena() == from.GetOwningArena()
90 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
91 && GetOwningArena() != nullptr
92 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
93 ) {
94 InternalSwap(&from);
95 } else {
96 CopyFrom(from);
97 }
98 return *this;
99 }
100
default_instance()101 static const DebugTensorWatch& default_instance() {
102 return *internal_default_instance();
103 }
internal_default_instance()104 static inline const DebugTensorWatch* internal_default_instance() {
105 return reinterpret_cast<const DebugTensorWatch*>(
106 &_DebugTensorWatch_default_instance_);
107 }
108 static constexpr int kIndexInFileMessages =
109 0;
110
swap(DebugTensorWatch & a,DebugTensorWatch & b)111 friend void swap(DebugTensorWatch& a, DebugTensorWatch& b) {
112 a.Swap(&b);
113 }
Swap(DebugTensorWatch * other)114 inline void Swap(DebugTensorWatch* other) {
115 if (other == this) return;
116 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
117 if (GetOwningArena() != nullptr &&
118 GetOwningArena() == other->GetOwningArena()) {
119 #else // PROTOBUF_FORCE_COPY_IN_SWAP
120 if (GetOwningArena() == other->GetOwningArena()) {
121 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
122 InternalSwap(other);
123 } else {
124 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
125 }
126 }
127 void UnsafeArenaSwap(DebugTensorWatch* other) {
128 if (other == this) return;
129 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
130 InternalSwap(other);
131 }
132
133 // implements Message ----------------------------------------------
134
135 DebugTensorWatch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
136 return CreateMaybeMessage<DebugTensorWatch>(arena);
137 }
138 DebugTensorWatch* New() const {
139 return New(nullptr);
140 }
141 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
142 void CopyFrom(const DebugTensorWatch& from);
143 void MergeFrom(const DebugTensorWatch& from);
144 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
145 bool IsInitialized() const final;
146
147 size_t ByteSizeLong() const final;
148 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
149 ::uint8_t* _InternalSerialize(
150 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
151 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
152
153 private:
154 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
155 void SharedDtor();
156 void SetCachedSize(int size) const;
157 void InternalSwap(DebugTensorWatch* other);
158
159 private:
160 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
161 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
162 return "tensorflow.DebugTensorWatch";
163 }
164 protected:
165 explicit DebugTensorWatch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
166 bool is_message_owned = false);
167 public:
168
169 std::string GetTypeName() const final;
170
171 // nested types ----------------------------------------------------
172
173 // accessors -------------------------------------------------------
174
175 enum : int {
176 kDebugOpsFieldNumber = 3,
177 kDebugUrlsFieldNumber = 4,
178 kNodeNameFieldNumber = 1,
179 kOutputSlotFieldNumber = 2,
180 kTolerateDebugOpCreationFailuresFieldNumber = 5,
181 };
182 // repeated string debug_ops = 3;
183 int debug_ops_size() const;
184 private:
185 int _internal_debug_ops_size() const;
186 public:
187 void clear_debug_ops();
188 const std::string& debug_ops(int index) const;
189 std::string* mutable_debug_ops(int index);
190 void set_debug_ops(int index, const std::string& value);
191 void set_debug_ops(int index, std::string&& value);
192 void set_debug_ops(int index, const char* value);
193 void set_debug_ops(int index, const char* value, size_t size);
194 std::string* add_debug_ops();
195 void add_debug_ops(const std::string& value);
196 void add_debug_ops(std::string&& value);
197 void add_debug_ops(const char* value);
198 void add_debug_ops(const char* value, size_t size);
199 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& debug_ops() const;
200 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_debug_ops();
201 private:
202 const std::string& _internal_debug_ops(int index) const;
203 std::string* _internal_add_debug_ops();
204 public:
205
206 // repeated string debug_urls = 4;
207 int debug_urls_size() const;
208 private:
209 int _internal_debug_urls_size() const;
210 public:
211 void clear_debug_urls();
212 const std::string& debug_urls(int index) const;
213 std::string* mutable_debug_urls(int index);
214 void set_debug_urls(int index, const std::string& value);
215 void set_debug_urls(int index, std::string&& value);
216 void set_debug_urls(int index, const char* value);
217 void set_debug_urls(int index, const char* value, size_t size);
218 std::string* add_debug_urls();
219 void add_debug_urls(const std::string& value);
220 void add_debug_urls(std::string&& value);
221 void add_debug_urls(const char* value);
222 void add_debug_urls(const char* value, size_t size);
223 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& debug_urls() const;
224 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_debug_urls();
225 private:
226 const std::string& _internal_debug_urls(int index) const;
227 std::string* _internal_add_debug_urls();
228 public:
229
230 // string node_name = 1;
231 void clear_node_name();
232 const std::string& node_name() const;
233 template <typename ArgT0 = const std::string&, typename... ArgT>
234 void set_node_name(ArgT0&& arg0, ArgT... args);
235 std::string* mutable_node_name();
236 PROTOBUF_NODISCARD std::string* release_node_name();
237 void set_allocated_node_name(std::string* node_name);
238 private:
239 const std::string& _internal_node_name() const;
240 inline PROTOBUF_ALWAYS_INLINE void _internal_set_node_name(const std::string& value);
241 std::string* _internal_mutable_node_name();
242 public:
243
244 // int32 output_slot = 2;
245 void clear_output_slot();
246 ::int32_t output_slot() const;
247 void set_output_slot(::int32_t value);
248 private:
249 ::int32_t _internal_output_slot() const;
250 void _internal_set_output_slot(::int32_t value);
251 public:
252
253 // bool tolerate_debug_op_creation_failures = 5;
254 void clear_tolerate_debug_op_creation_failures();
255 bool tolerate_debug_op_creation_failures() const;
256 void set_tolerate_debug_op_creation_failures(bool value);
257 private:
258 bool _internal_tolerate_debug_op_creation_failures() const;
259 void _internal_set_tolerate_debug_op_creation_failures(bool value);
260 public:
261
262 // @@protoc_insertion_point(class_scope:tensorflow.DebugTensorWatch)
263 private:
264 class _Internal;
265
266 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
267 typedef void InternalArenaConstructable_;
268 typedef void DestructorSkippable_;
269 struct Impl_ {
270 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> debug_ops_;
271 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> debug_urls_;
272 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr node_name_;
273 ::int32_t output_slot_;
274 bool tolerate_debug_op_creation_failures_;
275 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
276 };
277 union { Impl_ _impl_; };
278 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto;
279 };
280 // -------------------------------------------------------------------
281
282 class DebugOptions final :
283 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DebugOptions) */ {
284 public:
DebugOptions()285 inline DebugOptions() : DebugOptions(nullptr) {}
286 ~DebugOptions() override;
287 explicit PROTOBUF_CONSTEXPR DebugOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
288
289 DebugOptions(const DebugOptions& from);
DebugOptions(DebugOptions && from)290 DebugOptions(DebugOptions&& from) noexcept
291 : DebugOptions() {
292 *this = ::std::move(from);
293 }
294
295 inline DebugOptions& operator=(const DebugOptions& from) {
296 if (this == &from) return *this;
297 CopyFrom(from);
298 return *this;
299 }
300 inline DebugOptions& operator=(DebugOptions&& from) noexcept {
301 if (this == &from) return *this;
302 if (GetOwningArena() == from.GetOwningArena()
303 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
304 && GetOwningArena() != nullptr
305 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
306 ) {
307 InternalSwap(&from);
308 } else {
309 CopyFrom(from);
310 }
311 return *this;
312 }
313
default_instance()314 static const DebugOptions& default_instance() {
315 return *internal_default_instance();
316 }
internal_default_instance()317 static inline const DebugOptions* internal_default_instance() {
318 return reinterpret_cast<const DebugOptions*>(
319 &_DebugOptions_default_instance_);
320 }
321 static constexpr int kIndexInFileMessages =
322 1;
323
swap(DebugOptions & a,DebugOptions & b)324 friend void swap(DebugOptions& a, DebugOptions& b) {
325 a.Swap(&b);
326 }
Swap(DebugOptions * other)327 inline void Swap(DebugOptions* other) {
328 if (other == this) return;
329 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
330 if (GetOwningArena() != nullptr &&
331 GetOwningArena() == other->GetOwningArena()) {
332 #else // PROTOBUF_FORCE_COPY_IN_SWAP
333 if (GetOwningArena() == other->GetOwningArena()) {
334 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
335 InternalSwap(other);
336 } else {
337 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
338 }
339 }
340 void UnsafeArenaSwap(DebugOptions* other) {
341 if (other == this) return;
342 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
343 InternalSwap(other);
344 }
345
346 // implements Message ----------------------------------------------
347
348 DebugOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
349 return CreateMaybeMessage<DebugOptions>(arena);
350 }
351 DebugOptions* New() const {
352 return New(nullptr);
353 }
354 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
355 void CopyFrom(const DebugOptions& from);
356 void MergeFrom(const DebugOptions& from);
357 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
358 bool IsInitialized() const final;
359
360 size_t ByteSizeLong() const final;
361 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
362 ::uint8_t* _InternalSerialize(
363 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
364 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
365
366 private:
367 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
368 void SharedDtor();
369 void SetCachedSize(int size) const;
370 void InternalSwap(DebugOptions* other);
371
372 private:
373 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
374 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
375 return "tensorflow.DebugOptions";
376 }
377 protected:
378 explicit DebugOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
379 bool is_message_owned = false);
380 public:
381
382 std::string GetTypeName() const final;
383
384 // nested types ----------------------------------------------------
385
386 // accessors -------------------------------------------------------
387
388 enum : int {
389 kDebugTensorWatchOptsFieldNumber = 4,
390 kGlobalStepFieldNumber = 10,
391 kResetDiskByteUsageFieldNumber = 11,
392 };
393 // repeated .tensorflow.DebugTensorWatch debug_tensor_watch_opts = 4;
394 int debug_tensor_watch_opts_size() const;
395 private:
396 int _internal_debug_tensor_watch_opts_size() const;
397 public:
398 void clear_debug_tensor_watch_opts();
399 ::tensorflow::DebugTensorWatch* mutable_debug_tensor_watch_opts(int index);
400 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebugTensorWatch >*
401 mutable_debug_tensor_watch_opts();
402 private:
403 const ::tensorflow::DebugTensorWatch& _internal_debug_tensor_watch_opts(int index) const;
404 ::tensorflow::DebugTensorWatch* _internal_add_debug_tensor_watch_opts();
405 public:
406 const ::tensorflow::DebugTensorWatch& debug_tensor_watch_opts(int index) const;
407 ::tensorflow::DebugTensorWatch* add_debug_tensor_watch_opts();
408 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebugTensorWatch >&
409 debug_tensor_watch_opts() const;
410
411 // int64 global_step = 10;
412 void clear_global_step();
413 ::int64_t global_step() const;
414 void set_global_step(::int64_t value);
415 private:
416 ::int64_t _internal_global_step() const;
417 void _internal_set_global_step(::int64_t value);
418 public:
419
420 // bool reset_disk_byte_usage = 11;
421 void clear_reset_disk_byte_usage();
422 bool reset_disk_byte_usage() const;
423 void set_reset_disk_byte_usage(bool value);
424 private:
425 bool _internal_reset_disk_byte_usage() const;
426 void _internal_set_reset_disk_byte_usage(bool value);
427 public:
428
429 // @@protoc_insertion_point(class_scope:tensorflow.DebugOptions)
430 private:
431 class _Internal;
432
433 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
434 typedef void InternalArenaConstructable_;
435 typedef void DestructorSkippable_;
436 struct Impl_ {
437 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebugTensorWatch > debug_tensor_watch_opts_;
438 ::int64_t global_step_;
439 bool reset_disk_byte_usage_;
440 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
441 };
442 union { Impl_ _impl_; };
443 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto;
444 };
445 // -------------------------------------------------------------------
446
447 class DebuggedSourceFile final :
448 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DebuggedSourceFile) */ {
449 public:
DebuggedSourceFile()450 inline DebuggedSourceFile() : DebuggedSourceFile(nullptr) {}
451 ~DebuggedSourceFile() override;
452 explicit PROTOBUF_CONSTEXPR DebuggedSourceFile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
453
454 DebuggedSourceFile(const DebuggedSourceFile& from);
DebuggedSourceFile(DebuggedSourceFile && from)455 DebuggedSourceFile(DebuggedSourceFile&& from) noexcept
456 : DebuggedSourceFile() {
457 *this = ::std::move(from);
458 }
459
460 inline DebuggedSourceFile& operator=(const DebuggedSourceFile& from) {
461 if (this == &from) return *this;
462 CopyFrom(from);
463 return *this;
464 }
465 inline DebuggedSourceFile& operator=(DebuggedSourceFile&& from) noexcept {
466 if (this == &from) return *this;
467 if (GetOwningArena() == from.GetOwningArena()
468 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
469 && GetOwningArena() != nullptr
470 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
471 ) {
472 InternalSwap(&from);
473 } else {
474 CopyFrom(from);
475 }
476 return *this;
477 }
478
default_instance()479 static const DebuggedSourceFile& default_instance() {
480 return *internal_default_instance();
481 }
internal_default_instance()482 static inline const DebuggedSourceFile* internal_default_instance() {
483 return reinterpret_cast<const DebuggedSourceFile*>(
484 &_DebuggedSourceFile_default_instance_);
485 }
486 static constexpr int kIndexInFileMessages =
487 2;
488
swap(DebuggedSourceFile & a,DebuggedSourceFile & b)489 friend void swap(DebuggedSourceFile& a, DebuggedSourceFile& b) {
490 a.Swap(&b);
491 }
Swap(DebuggedSourceFile * other)492 inline void Swap(DebuggedSourceFile* other) {
493 if (other == this) return;
494 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
495 if (GetOwningArena() != nullptr &&
496 GetOwningArena() == other->GetOwningArena()) {
497 #else // PROTOBUF_FORCE_COPY_IN_SWAP
498 if (GetOwningArena() == other->GetOwningArena()) {
499 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
500 InternalSwap(other);
501 } else {
502 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
503 }
504 }
505 void UnsafeArenaSwap(DebuggedSourceFile* other) {
506 if (other == this) return;
507 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
508 InternalSwap(other);
509 }
510
511 // implements Message ----------------------------------------------
512
513 DebuggedSourceFile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
514 return CreateMaybeMessage<DebuggedSourceFile>(arena);
515 }
516 DebuggedSourceFile* New() const {
517 return New(nullptr);
518 }
519 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
520 void CopyFrom(const DebuggedSourceFile& from);
521 void MergeFrom(const DebuggedSourceFile& from);
522 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
523 bool IsInitialized() const final;
524
525 size_t ByteSizeLong() const final;
526 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
527 ::uint8_t* _InternalSerialize(
528 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
529 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
530
531 private:
532 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
533 void SharedDtor();
534 void SetCachedSize(int size) const;
535 void InternalSwap(DebuggedSourceFile* other);
536
537 private:
538 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
539 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
540 return "tensorflow.DebuggedSourceFile";
541 }
542 protected:
543 explicit DebuggedSourceFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
544 bool is_message_owned = false);
545 public:
546
547 std::string GetTypeName() const final;
548
549 // nested types ----------------------------------------------------
550
551 // accessors -------------------------------------------------------
552
553 enum : int {
554 kLinesFieldNumber = 5,
555 kHostFieldNumber = 1,
556 kFilePathFieldNumber = 2,
557 kLastModifiedFieldNumber = 3,
558 kBytesFieldNumber = 4,
559 };
560 // repeated string lines = 5;
561 int lines_size() const;
562 private:
563 int _internal_lines_size() const;
564 public:
565 void clear_lines();
566 const std::string& lines(int index) const;
567 std::string* mutable_lines(int index);
568 void set_lines(int index, const std::string& value);
569 void set_lines(int index, std::string&& value);
570 void set_lines(int index, const char* value);
571 void set_lines(int index, const char* value, size_t size);
572 std::string* add_lines();
573 void add_lines(const std::string& value);
574 void add_lines(std::string&& value);
575 void add_lines(const char* value);
576 void add_lines(const char* value, size_t size);
577 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& lines() const;
578 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_lines();
579 private:
580 const std::string& _internal_lines(int index) const;
581 std::string* _internal_add_lines();
582 public:
583
584 // string host = 1;
585 void clear_host();
586 const std::string& host() const;
587 template <typename ArgT0 = const std::string&, typename... ArgT>
588 void set_host(ArgT0&& arg0, ArgT... args);
589 std::string* mutable_host();
590 PROTOBUF_NODISCARD std::string* release_host();
591 void set_allocated_host(std::string* host);
592 private:
593 const std::string& _internal_host() const;
594 inline PROTOBUF_ALWAYS_INLINE void _internal_set_host(const std::string& value);
595 std::string* _internal_mutable_host();
596 public:
597
598 // string file_path = 2;
599 void clear_file_path();
600 const std::string& file_path() const;
601 template <typename ArgT0 = const std::string&, typename... ArgT>
602 void set_file_path(ArgT0&& arg0, ArgT... args);
603 std::string* mutable_file_path();
604 PROTOBUF_NODISCARD std::string* release_file_path();
605 void set_allocated_file_path(std::string* file_path);
606 private:
607 const std::string& _internal_file_path() const;
608 inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_path(const std::string& value);
609 std::string* _internal_mutable_file_path();
610 public:
611
612 // int64 last_modified = 3;
613 void clear_last_modified();
614 ::int64_t last_modified() const;
615 void set_last_modified(::int64_t value);
616 private:
617 ::int64_t _internal_last_modified() const;
618 void _internal_set_last_modified(::int64_t value);
619 public:
620
621 // int64 bytes = 4;
622 void clear_bytes();
623 ::int64_t bytes() const;
624 void set_bytes(::int64_t value);
625 private:
626 ::int64_t _internal_bytes() const;
627 void _internal_set_bytes(::int64_t value);
628 public:
629
630 // @@protoc_insertion_point(class_scope:tensorflow.DebuggedSourceFile)
631 private:
632 class _Internal;
633
634 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
635 typedef void InternalArenaConstructable_;
636 typedef void DestructorSkippable_;
637 struct Impl_ {
638 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> lines_;
639 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr host_;
640 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_path_;
641 ::int64_t last_modified_;
642 ::int64_t bytes_;
643 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
644 };
645 union { Impl_ _impl_; };
646 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto;
647 };
648 // -------------------------------------------------------------------
649
650 class DebuggedSourceFiles final :
651 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:tensorflow.DebuggedSourceFiles) */ {
652 public:
DebuggedSourceFiles()653 inline DebuggedSourceFiles() : DebuggedSourceFiles(nullptr) {}
654 ~DebuggedSourceFiles() override;
655 explicit PROTOBUF_CONSTEXPR DebuggedSourceFiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
656
657 DebuggedSourceFiles(const DebuggedSourceFiles& from);
DebuggedSourceFiles(DebuggedSourceFiles && from)658 DebuggedSourceFiles(DebuggedSourceFiles&& from) noexcept
659 : DebuggedSourceFiles() {
660 *this = ::std::move(from);
661 }
662
663 inline DebuggedSourceFiles& operator=(const DebuggedSourceFiles& from) {
664 if (this == &from) return *this;
665 CopyFrom(from);
666 return *this;
667 }
668 inline DebuggedSourceFiles& operator=(DebuggedSourceFiles&& from) noexcept {
669 if (this == &from) return *this;
670 if (GetOwningArena() == from.GetOwningArena()
671 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
672 && GetOwningArena() != nullptr
673 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
674 ) {
675 InternalSwap(&from);
676 } else {
677 CopyFrom(from);
678 }
679 return *this;
680 }
681
default_instance()682 static const DebuggedSourceFiles& default_instance() {
683 return *internal_default_instance();
684 }
internal_default_instance()685 static inline const DebuggedSourceFiles* internal_default_instance() {
686 return reinterpret_cast<const DebuggedSourceFiles*>(
687 &_DebuggedSourceFiles_default_instance_);
688 }
689 static constexpr int kIndexInFileMessages =
690 3;
691
swap(DebuggedSourceFiles & a,DebuggedSourceFiles & b)692 friend void swap(DebuggedSourceFiles& a, DebuggedSourceFiles& b) {
693 a.Swap(&b);
694 }
Swap(DebuggedSourceFiles * other)695 inline void Swap(DebuggedSourceFiles* other) {
696 if (other == this) return;
697 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
698 if (GetOwningArena() != nullptr &&
699 GetOwningArena() == other->GetOwningArena()) {
700 #else // PROTOBUF_FORCE_COPY_IN_SWAP
701 if (GetOwningArena() == other->GetOwningArena()) {
702 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
703 InternalSwap(other);
704 } else {
705 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
706 }
707 }
708 void UnsafeArenaSwap(DebuggedSourceFiles* other) {
709 if (other == this) return;
710 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
711 InternalSwap(other);
712 }
713
714 // implements Message ----------------------------------------------
715
716 DebuggedSourceFiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
717 return CreateMaybeMessage<DebuggedSourceFiles>(arena);
718 }
719 DebuggedSourceFiles* New() const {
720 return New(nullptr);
721 }
722 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
723 void CopyFrom(const DebuggedSourceFiles& from);
724 void MergeFrom(const DebuggedSourceFiles& from);
725 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
726 bool IsInitialized() const final;
727
728 size_t ByteSizeLong() const final;
729 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
730 ::uint8_t* _InternalSerialize(
731 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
732 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
733
734 private:
735 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
736 void SharedDtor();
737 void SetCachedSize(int size) const;
738 void InternalSwap(DebuggedSourceFiles* other);
739
740 private:
741 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
742 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
743 return "tensorflow.DebuggedSourceFiles";
744 }
745 protected:
746 explicit DebuggedSourceFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
747 bool is_message_owned = false);
748 public:
749
750 std::string GetTypeName() const final;
751
752 // nested types ----------------------------------------------------
753
754 // accessors -------------------------------------------------------
755
756 enum : int {
757 kSourceFilesFieldNumber = 1,
758 };
759 // repeated .tensorflow.DebuggedSourceFile source_files = 1;
760 int source_files_size() const;
761 private:
762 int _internal_source_files_size() const;
763 public:
764 void clear_source_files();
765 ::tensorflow::DebuggedSourceFile* mutable_source_files(int index);
766 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebuggedSourceFile >*
767 mutable_source_files();
768 private:
769 const ::tensorflow::DebuggedSourceFile& _internal_source_files(int index) const;
770 ::tensorflow::DebuggedSourceFile* _internal_add_source_files();
771 public:
772 const ::tensorflow::DebuggedSourceFile& source_files(int index) const;
773 ::tensorflow::DebuggedSourceFile* add_source_files();
774 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebuggedSourceFile >&
775 source_files() const;
776
777 // @@protoc_insertion_point(class_scope:tensorflow.DebuggedSourceFiles)
778 private:
779 class _Internal;
780
781 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
782 typedef void InternalArenaConstructable_;
783 typedef void DestructorSkippable_;
784 struct Impl_ {
785 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebuggedSourceFile > source_files_;
786 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
787 };
788 union { Impl_ _impl_; };
789 friend struct ::TableStruct_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto;
790 };
791 // ===================================================================
792
793
794 // ===================================================================
795
796 #ifdef __GNUC__
797 #pragma GCC diagnostic push
798 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
799 #endif // __GNUC__
800 // DebugTensorWatch
801
802 // string node_name = 1;
clear_node_name()803 inline void DebugTensorWatch::clear_node_name() {
804 _impl_.node_name_.ClearToEmpty();
805 }
node_name()806 inline const std::string& DebugTensorWatch::node_name() const {
807 // @@protoc_insertion_point(field_get:tensorflow.DebugTensorWatch.node_name)
808 return _internal_node_name();
809 }
810 template <typename ArgT0, typename... ArgT>
811 inline PROTOBUF_ALWAYS_INLINE
set_node_name(ArgT0 && arg0,ArgT...args)812 void DebugTensorWatch::set_node_name(ArgT0&& arg0, ArgT... args) {
813
814 _impl_.node_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
815 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.node_name)
816 }
mutable_node_name()817 inline std::string* DebugTensorWatch::mutable_node_name() {
818 std::string* _s = _internal_mutable_node_name();
819 // @@protoc_insertion_point(field_mutable:tensorflow.DebugTensorWatch.node_name)
820 return _s;
821 }
_internal_node_name()822 inline const std::string& DebugTensorWatch::_internal_node_name() const {
823 return _impl_.node_name_.Get();
824 }
_internal_set_node_name(const std::string & value)825 inline void DebugTensorWatch::_internal_set_node_name(const std::string& value) {
826
827 _impl_.node_name_.Set(value, GetArenaForAllocation());
828 }
_internal_mutable_node_name()829 inline std::string* DebugTensorWatch::_internal_mutable_node_name() {
830
831 return _impl_.node_name_.Mutable(GetArenaForAllocation());
832 }
release_node_name()833 inline std::string* DebugTensorWatch::release_node_name() {
834 // @@protoc_insertion_point(field_release:tensorflow.DebugTensorWatch.node_name)
835 return _impl_.node_name_.Release();
836 }
set_allocated_node_name(std::string * node_name)837 inline void DebugTensorWatch::set_allocated_node_name(std::string* node_name) {
838 _impl_.node_name_.SetAllocated(node_name, GetArenaForAllocation());
839 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
840 if (_impl_.node_name_.IsDefault()) {
841 _impl_.node_name_.Set("", GetArenaForAllocation());
842 }
843 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
844 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebugTensorWatch.node_name)
845 }
846
847 // int32 output_slot = 2;
clear_output_slot()848 inline void DebugTensorWatch::clear_output_slot() {
849 _impl_.output_slot_ = 0;
850 }
_internal_output_slot()851 inline ::int32_t DebugTensorWatch::_internal_output_slot() const {
852 return _impl_.output_slot_;
853 }
output_slot()854 inline ::int32_t DebugTensorWatch::output_slot() const {
855 // @@protoc_insertion_point(field_get:tensorflow.DebugTensorWatch.output_slot)
856 return _internal_output_slot();
857 }
_internal_set_output_slot(::int32_t value)858 inline void DebugTensorWatch::_internal_set_output_slot(::int32_t value) {
859
860 _impl_.output_slot_ = value;
861 }
set_output_slot(::int32_t value)862 inline void DebugTensorWatch::set_output_slot(::int32_t value) {
863 _internal_set_output_slot(value);
864 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.output_slot)
865 }
866
867 // repeated string debug_ops = 3;
_internal_debug_ops_size()868 inline int DebugTensorWatch::_internal_debug_ops_size() const {
869 return _impl_.debug_ops_.size();
870 }
debug_ops_size()871 inline int DebugTensorWatch::debug_ops_size() const {
872 return _internal_debug_ops_size();
873 }
clear_debug_ops()874 inline void DebugTensorWatch::clear_debug_ops() {
875 _impl_.debug_ops_.Clear();
876 }
add_debug_ops()877 inline std::string* DebugTensorWatch::add_debug_ops() {
878 std::string* _s = _internal_add_debug_ops();
879 // @@protoc_insertion_point(field_add_mutable:tensorflow.DebugTensorWatch.debug_ops)
880 return _s;
881 }
_internal_debug_ops(int index)882 inline const std::string& DebugTensorWatch::_internal_debug_ops(int index) const {
883 return _impl_.debug_ops_.Get(index);
884 }
debug_ops(int index)885 inline const std::string& DebugTensorWatch::debug_ops(int index) const {
886 // @@protoc_insertion_point(field_get:tensorflow.DebugTensorWatch.debug_ops)
887 return _internal_debug_ops(index);
888 }
mutable_debug_ops(int index)889 inline std::string* DebugTensorWatch::mutable_debug_ops(int index) {
890 // @@protoc_insertion_point(field_mutable:tensorflow.DebugTensorWatch.debug_ops)
891 return _impl_.debug_ops_.Mutable(index);
892 }
set_debug_ops(int index,const std::string & value)893 inline void DebugTensorWatch::set_debug_ops(int index, const std::string& value) {
894 _impl_.debug_ops_.Mutable(index)->assign(value);
895 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.debug_ops)
896 }
set_debug_ops(int index,std::string && value)897 inline void DebugTensorWatch::set_debug_ops(int index, std::string&& value) {
898 _impl_.debug_ops_.Mutable(index)->assign(std::move(value));
899 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.debug_ops)
900 }
set_debug_ops(int index,const char * value)901 inline void DebugTensorWatch::set_debug_ops(int index, const char* value) {
902 GOOGLE_DCHECK(value != nullptr);
903 _impl_.debug_ops_.Mutable(index)->assign(value);
904 // @@protoc_insertion_point(field_set_char:tensorflow.DebugTensorWatch.debug_ops)
905 }
set_debug_ops(int index,const char * value,size_t size)906 inline void DebugTensorWatch::set_debug_ops(int index, const char* value, size_t size) {
907 _impl_.debug_ops_.Mutable(index)->assign(
908 reinterpret_cast<const char*>(value), size);
909 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebugTensorWatch.debug_ops)
910 }
_internal_add_debug_ops()911 inline std::string* DebugTensorWatch::_internal_add_debug_ops() {
912 return _impl_.debug_ops_.Add();
913 }
add_debug_ops(const std::string & value)914 inline void DebugTensorWatch::add_debug_ops(const std::string& value) {
915 _impl_.debug_ops_.Add()->assign(value);
916 // @@protoc_insertion_point(field_add:tensorflow.DebugTensorWatch.debug_ops)
917 }
add_debug_ops(std::string && value)918 inline void DebugTensorWatch::add_debug_ops(std::string&& value) {
919 _impl_.debug_ops_.Add(std::move(value));
920 // @@protoc_insertion_point(field_add:tensorflow.DebugTensorWatch.debug_ops)
921 }
add_debug_ops(const char * value)922 inline void DebugTensorWatch::add_debug_ops(const char* value) {
923 GOOGLE_DCHECK(value != nullptr);
924 _impl_.debug_ops_.Add()->assign(value);
925 // @@protoc_insertion_point(field_add_char:tensorflow.DebugTensorWatch.debug_ops)
926 }
add_debug_ops(const char * value,size_t size)927 inline void DebugTensorWatch::add_debug_ops(const char* value, size_t size) {
928 _impl_.debug_ops_.Add()->assign(reinterpret_cast<const char*>(value), size);
929 // @@protoc_insertion_point(field_add_pointer:tensorflow.DebugTensorWatch.debug_ops)
930 }
931 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
debug_ops()932 DebugTensorWatch::debug_ops() const {
933 // @@protoc_insertion_point(field_list:tensorflow.DebugTensorWatch.debug_ops)
934 return _impl_.debug_ops_;
935 }
936 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_debug_ops()937 DebugTensorWatch::mutable_debug_ops() {
938 // @@protoc_insertion_point(field_mutable_list:tensorflow.DebugTensorWatch.debug_ops)
939 return &_impl_.debug_ops_;
940 }
941
942 // repeated string debug_urls = 4;
_internal_debug_urls_size()943 inline int DebugTensorWatch::_internal_debug_urls_size() const {
944 return _impl_.debug_urls_.size();
945 }
debug_urls_size()946 inline int DebugTensorWatch::debug_urls_size() const {
947 return _internal_debug_urls_size();
948 }
clear_debug_urls()949 inline void DebugTensorWatch::clear_debug_urls() {
950 _impl_.debug_urls_.Clear();
951 }
add_debug_urls()952 inline std::string* DebugTensorWatch::add_debug_urls() {
953 std::string* _s = _internal_add_debug_urls();
954 // @@protoc_insertion_point(field_add_mutable:tensorflow.DebugTensorWatch.debug_urls)
955 return _s;
956 }
_internal_debug_urls(int index)957 inline const std::string& DebugTensorWatch::_internal_debug_urls(int index) const {
958 return _impl_.debug_urls_.Get(index);
959 }
debug_urls(int index)960 inline const std::string& DebugTensorWatch::debug_urls(int index) const {
961 // @@protoc_insertion_point(field_get:tensorflow.DebugTensorWatch.debug_urls)
962 return _internal_debug_urls(index);
963 }
mutable_debug_urls(int index)964 inline std::string* DebugTensorWatch::mutable_debug_urls(int index) {
965 // @@protoc_insertion_point(field_mutable:tensorflow.DebugTensorWatch.debug_urls)
966 return _impl_.debug_urls_.Mutable(index);
967 }
set_debug_urls(int index,const std::string & value)968 inline void DebugTensorWatch::set_debug_urls(int index, const std::string& value) {
969 _impl_.debug_urls_.Mutable(index)->assign(value);
970 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.debug_urls)
971 }
set_debug_urls(int index,std::string && value)972 inline void DebugTensorWatch::set_debug_urls(int index, std::string&& value) {
973 _impl_.debug_urls_.Mutable(index)->assign(std::move(value));
974 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.debug_urls)
975 }
set_debug_urls(int index,const char * value)976 inline void DebugTensorWatch::set_debug_urls(int index, const char* value) {
977 GOOGLE_DCHECK(value != nullptr);
978 _impl_.debug_urls_.Mutable(index)->assign(value);
979 // @@protoc_insertion_point(field_set_char:tensorflow.DebugTensorWatch.debug_urls)
980 }
set_debug_urls(int index,const char * value,size_t size)981 inline void DebugTensorWatch::set_debug_urls(int index, const char* value, size_t size) {
982 _impl_.debug_urls_.Mutable(index)->assign(
983 reinterpret_cast<const char*>(value), size);
984 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebugTensorWatch.debug_urls)
985 }
_internal_add_debug_urls()986 inline std::string* DebugTensorWatch::_internal_add_debug_urls() {
987 return _impl_.debug_urls_.Add();
988 }
add_debug_urls(const std::string & value)989 inline void DebugTensorWatch::add_debug_urls(const std::string& value) {
990 _impl_.debug_urls_.Add()->assign(value);
991 // @@protoc_insertion_point(field_add:tensorflow.DebugTensorWatch.debug_urls)
992 }
add_debug_urls(std::string && value)993 inline void DebugTensorWatch::add_debug_urls(std::string&& value) {
994 _impl_.debug_urls_.Add(std::move(value));
995 // @@protoc_insertion_point(field_add:tensorflow.DebugTensorWatch.debug_urls)
996 }
add_debug_urls(const char * value)997 inline void DebugTensorWatch::add_debug_urls(const char* value) {
998 GOOGLE_DCHECK(value != nullptr);
999 _impl_.debug_urls_.Add()->assign(value);
1000 // @@protoc_insertion_point(field_add_char:tensorflow.DebugTensorWatch.debug_urls)
1001 }
add_debug_urls(const char * value,size_t size)1002 inline void DebugTensorWatch::add_debug_urls(const char* value, size_t size) {
1003 _impl_.debug_urls_.Add()->assign(reinterpret_cast<const char*>(value), size);
1004 // @@protoc_insertion_point(field_add_pointer:tensorflow.DebugTensorWatch.debug_urls)
1005 }
1006 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
debug_urls()1007 DebugTensorWatch::debug_urls() const {
1008 // @@protoc_insertion_point(field_list:tensorflow.DebugTensorWatch.debug_urls)
1009 return _impl_.debug_urls_;
1010 }
1011 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_debug_urls()1012 DebugTensorWatch::mutable_debug_urls() {
1013 // @@protoc_insertion_point(field_mutable_list:tensorflow.DebugTensorWatch.debug_urls)
1014 return &_impl_.debug_urls_;
1015 }
1016
1017 // bool tolerate_debug_op_creation_failures = 5;
clear_tolerate_debug_op_creation_failures()1018 inline void DebugTensorWatch::clear_tolerate_debug_op_creation_failures() {
1019 _impl_.tolerate_debug_op_creation_failures_ = false;
1020 }
_internal_tolerate_debug_op_creation_failures()1021 inline bool DebugTensorWatch::_internal_tolerate_debug_op_creation_failures() const {
1022 return _impl_.tolerate_debug_op_creation_failures_;
1023 }
tolerate_debug_op_creation_failures()1024 inline bool DebugTensorWatch::tolerate_debug_op_creation_failures() const {
1025 // @@protoc_insertion_point(field_get:tensorflow.DebugTensorWatch.tolerate_debug_op_creation_failures)
1026 return _internal_tolerate_debug_op_creation_failures();
1027 }
_internal_set_tolerate_debug_op_creation_failures(bool value)1028 inline void DebugTensorWatch::_internal_set_tolerate_debug_op_creation_failures(bool value) {
1029
1030 _impl_.tolerate_debug_op_creation_failures_ = value;
1031 }
set_tolerate_debug_op_creation_failures(bool value)1032 inline void DebugTensorWatch::set_tolerate_debug_op_creation_failures(bool value) {
1033 _internal_set_tolerate_debug_op_creation_failures(value);
1034 // @@protoc_insertion_point(field_set:tensorflow.DebugTensorWatch.tolerate_debug_op_creation_failures)
1035 }
1036
1037 // -------------------------------------------------------------------
1038
1039 // DebugOptions
1040
1041 // repeated .tensorflow.DebugTensorWatch debug_tensor_watch_opts = 4;
_internal_debug_tensor_watch_opts_size()1042 inline int DebugOptions::_internal_debug_tensor_watch_opts_size() const {
1043 return _impl_.debug_tensor_watch_opts_.size();
1044 }
debug_tensor_watch_opts_size()1045 inline int DebugOptions::debug_tensor_watch_opts_size() const {
1046 return _internal_debug_tensor_watch_opts_size();
1047 }
clear_debug_tensor_watch_opts()1048 inline void DebugOptions::clear_debug_tensor_watch_opts() {
1049 _impl_.debug_tensor_watch_opts_.Clear();
1050 }
mutable_debug_tensor_watch_opts(int index)1051 inline ::tensorflow::DebugTensorWatch* DebugOptions::mutable_debug_tensor_watch_opts(int index) {
1052 // @@protoc_insertion_point(field_mutable:tensorflow.DebugOptions.debug_tensor_watch_opts)
1053 return _impl_.debug_tensor_watch_opts_.Mutable(index);
1054 }
1055 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebugTensorWatch >*
mutable_debug_tensor_watch_opts()1056 DebugOptions::mutable_debug_tensor_watch_opts() {
1057 // @@protoc_insertion_point(field_mutable_list:tensorflow.DebugOptions.debug_tensor_watch_opts)
1058 return &_impl_.debug_tensor_watch_opts_;
1059 }
_internal_debug_tensor_watch_opts(int index)1060 inline const ::tensorflow::DebugTensorWatch& DebugOptions::_internal_debug_tensor_watch_opts(int index) const {
1061 return _impl_.debug_tensor_watch_opts_.Get(index);
1062 }
debug_tensor_watch_opts(int index)1063 inline const ::tensorflow::DebugTensorWatch& DebugOptions::debug_tensor_watch_opts(int index) const {
1064 // @@protoc_insertion_point(field_get:tensorflow.DebugOptions.debug_tensor_watch_opts)
1065 return _internal_debug_tensor_watch_opts(index);
1066 }
_internal_add_debug_tensor_watch_opts()1067 inline ::tensorflow::DebugTensorWatch* DebugOptions::_internal_add_debug_tensor_watch_opts() {
1068 return _impl_.debug_tensor_watch_opts_.Add();
1069 }
add_debug_tensor_watch_opts()1070 inline ::tensorflow::DebugTensorWatch* DebugOptions::add_debug_tensor_watch_opts() {
1071 ::tensorflow::DebugTensorWatch* _add = _internal_add_debug_tensor_watch_opts();
1072 // @@protoc_insertion_point(field_add:tensorflow.DebugOptions.debug_tensor_watch_opts)
1073 return _add;
1074 }
1075 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebugTensorWatch >&
debug_tensor_watch_opts()1076 DebugOptions::debug_tensor_watch_opts() const {
1077 // @@protoc_insertion_point(field_list:tensorflow.DebugOptions.debug_tensor_watch_opts)
1078 return _impl_.debug_tensor_watch_opts_;
1079 }
1080
1081 // int64 global_step = 10;
clear_global_step()1082 inline void DebugOptions::clear_global_step() {
1083 _impl_.global_step_ = ::int64_t{0};
1084 }
_internal_global_step()1085 inline ::int64_t DebugOptions::_internal_global_step() const {
1086 return _impl_.global_step_;
1087 }
global_step()1088 inline ::int64_t DebugOptions::global_step() const {
1089 // @@protoc_insertion_point(field_get:tensorflow.DebugOptions.global_step)
1090 return _internal_global_step();
1091 }
_internal_set_global_step(::int64_t value)1092 inline void DebugOptions::_internal_set_global_step(::int64_t value) {
1093
1094 _impl_.global_step_ = value;
1095 }
set_global_step(::int64_t value)1096 inline void DebugOptions::set_global_step(::int64_t value) {
1097 _internal_set_global_step(value);
1098 // @@protoc_insertion_point(field_set:tensorflow.DebugOptions.global_step)
1099 }
1100
1101 // bool reset_disk_byte_usage = 11;
clear_reset_disk_byte_usage()1102 inline void DebugOptions::clear_reset_disk_byte_usage() {
1103 _impl_.reset_disk_byte_usage_ = false;
1104 }
_internal_reset_disk_byte_usage()1105 inline bool DebugOptions::_internal_reset_disk_byte_usage() const {
1106 return _impl_.reset_disk_byte_usage_;
1107 }
reset_disk_byte_usage()1108 inline bool DebugOptions::reset_disk_byte_usage() const {
1109 // @@protoc_insertion_point(field_get:tensorflow.DebugOptions.reset_disk_byte_usage)
1110 return _internal_reset_disk_byte_usage();
1111 }
_internal_set_reset_disk_byte_usage(bool value)1112 inline void DebugOptions::_internal_set_reset_disk_byte_usage(bool value) {
1113
1114 _impl_.reset_disk_byte_usage_ = value;
1115 }
set_reset_disk_byte_usage(bool value)1116 inline void DebugOptions::set_reset_disk_byte_usage(bool value) {
1117 _internal_set_reset_disk_byte_usage(value);
1118 // @@protoc_insertion_point(field_set:tensorflow.DebugOptions.reset_disk_byte_usage)
1119 }
1120
1121 // -------------------------------------------------------------------
1122
1123 // DebuggedSourceFile
1124
1125 // string host = 1;
clear_host()1126 inline void DebuggedSourceFile::clear_host() {
1127 _impl_.host_.ClearToEmpty();
1128 }
host()1129 inline const std::string& DebuggedSourceFile::host() const {
1130 // @@protoc_insertion_point(field_get:tensorflow.DebuggedSourceFile.host)
1131 return _internal_host();
1132 }
1133 template <typename ArgT0, typename... ArgT>
1134 inline PROTOBUF_ALWAYS_INLINE
set_host(ArgT0 && arg0,ArgT...args)1135 void DebuggedSourceFile::set_host(ArgT0&& arg0, ArgT... args) {
1136
1137 _impl_.host_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1138 // @@protoc_insertion_point(field_set:tensorflow.DebuggedSourceFile.host)
1139 }
mutable_host()1140 inline std::string* DebuggedSourceFile::mutable_host() {
1141 std::string* _s = _internal_mutable_host();
1142 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedSourceFile.host)
1143 return _s;
1144 }
_internal_host()1145 inline const std::string& DebuggedSourceFile::_internal_host() const {
1146 return _impl_.host_.Get();
1147 }
_internal_set_host(const std::string & value)1148 inline void DebuggedSourceFile::_internal_set_host(const std::string& value) {
1149
1150 _impl_.host_.Set(value, GetArenaForAllocation());
1151 }
_internal_mutable_host()1152 inline std::string* DebuggedSourceFile::_internal_mutable_host() {
1153
1154 return _impl_.host_.Mutable(GetArenaForAllocation());
1155 }
release_host()1156 inline std::string* DebuggedSourceFile::release_host() {
1157 // @@protoc_insertion_point(field_release:tensorflow.DebuggedSourceFile.host)
1158 return _impl_.host_.Release();
1159 }
set_allocated_host(std::string * host)1160 inline void DebuggedSourceFile::set_allocated_host(std::string* host) {
1161 _impl_.host_.SetAllocated(host, GetArenaForAllocation());
1162 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1163 if (_impl_.host_.IsDefault()) {
1164 _impl_.host_.Set("", GetArenaForAllocation());
1165 }
1166 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1167 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedSourceFile.host)
1168 }
1169
1170 // string file_path = 2;
clear_file_path()1171 inline void DebuggedSourceFile::clear_file_path() {
1172 _impl_.file_path_.ClearToEmpty();
1173 }
file_path()1174 inline const std::string& DebuggedSourceFile::file_path() const {
1175 // @@protoc_insertion_point(field_get:tensorflow.DebuggedSourceFile.file_path)
1176 return _internal_file_path();
1177 }
1178 template <typename ArgT0, typename... ArgT>
1179 inline PROTOBUF_ALWAYS_INLINE
set_file_path(ArgT0 && arg0,ArgT...args)1180 void DebuggedSourceFile::set_file_path(ArgT0&& arg0, ArgT... args) {
1181
1182 _impl_.file_path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1183 // @@protoc_insertion_point(field_set:tensorflow.DebuggedSourceFile.file_path)
1184 }
mutable_file_path()1185 inline std::string* DebuggedSourceFile::mutable_file_path() {
1186 std::string* _s = _internal_mutable_file_path();
1187 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedSourceFile.file_path)
1188 return _s;
1189 }
_internal_file_path()1190 inline const std::string& DebuggedSourceFile::_internal_file_path() const {
1191 return _impl_.file_path_.Get();
1192 }
_internal_set_file_path(const std::string & value)1193 inline void DebuggedSourceFile::_internal_set_file_path(const std::string& value) {
1194
1195 _impl_.file_path_.Set(value, GetArenaForAllocation());
1196 }
_internal_mutable_file_path()1197 inline std::string* DebuggedSourceFile::_internal_mutable_file_path() {
1198
1199 return _impl_.file_path_.Mutable(GetArenaForAllocation());
1200 }
release_file_path()1201 inline std::string* DebuggedSourceFile::release_file_path() {
1202 // @@protoc_insertion_point(field_release:tensorflow.DebuggedSourceFile.file_path)
1203 return _impl_.file_path_.Release();
1204 }
set_allocated_file_path(std::string * file_path)1205 inline void DebuggedSourceFile::set_allocated_file_path(std::string* file_path) {
1206 _impl_.file_path_.SetAllocated(file_path, GetArenaForAllocation());
1207 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1208 if (_impl_.file_path_.IsDefault()) {
1209 _impl_.file_path_.Set("", GetArenaForAllocation());
1210 }
1211 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1212 // @@protoc_insertion_point(field_set_allocated:tensorflow.DebuggedSourceFile.file_path)
1213 }
1214
1215 // int64 last_modified = 3;
clear_last_modified()1216 inline void DebuggedSourceFile::clear_last_modified() {
1217 _impl_.last_modified_ = ::int64_t{0};
1218 }
_internal_last_modified()1219 inline ::int64_t DebuggedSourceFile::_internal_last_modified() const {
1220 return _impl_.last_modified_;
1221 }
last_modified()1222 inline ::int64_t DebuggedSourceFile::last_modified() const {
1223 // @@protoc_insertion_point(field_get:tensorflow.DebuggedSourceFile.last_modified)
1224 return _internal_last_modified();
1225 }
_internal_set_last_modified(::int64_t value)1226 inline void DebuggedSourceFile::_internal_set_last_modified(::int64_t value) {
1227
1228 _impl_.last_modified_ = value;
1229 }
set_last_modified(::int64_t value)1230 inline void DebuggedSourceFile::set_last_modified(::int64_t value) {
1231 _internal_set_last_modified(value);
1232 // @@protoc_insertion_point(field_set:tensorflow.DebuggedSourceFile.last_modified)
1233 }
1234
1235 // int64 bytes = 4;
clear_bytes()1236 inline void DebuggedSourceFile::clear_bytes() {
1237 _impl_.bytes_ = ::int64_t{0};
1238 }
_internal_bytes()1239 inline ::int64_t DebuggedSourceFile::_internal_bytes() const {
1240 return _impl_.bytes_;
1241 }
bytes()1242 inline ::int64_t DebuggedSourceFile::bytes() const {
1243 // @@protoc_insertion_point(field_get:tensorflow.DebuggedSourceFile.bytes)
1244 return _internal_bytes();
1245 }
_internal_set_bytes(::int64_t value)1246 inline void DebuggedSourceFile::_internal_set_bytes(::int64_t value) {
1247
1248 _impl_.bytes_ = value;
1249 }
set_bytes(::int64_t value)1250 inline void DebuggedSourceFile::set_bytes(::int64_t value) {
1251 _internal_set_bytes(value);
1252 // @@protoc_insertion_point(field_set:tensorflow.DebuggedSourceFile.bytes)
1253 }
1254
1255 // repeated string lines = 5;
_internal_lines_size()1256 inline int DebuggedSourceFile::_internal_lines_size() const {
1257 return _impl_.lines_.size();
1258 }
lines_size()1259 inline int DebuggedSourceFile::lines_size() const {
1260 return _internal_lines_size();
1261 }
clear_lines()1262 inline void DebuggedSourceFile::clear_lines() {
1263 _impl_.lines_.Clear();
1264 }
add_lines()1265 inline std::string* DebuggedSourceFile::add_lines() {
1266 std::string* _s = _internal_add_lines();
1267 // @@protoc_insertion_point(field_add_mutable:tensorflow.DebuggedSourceFile.lines)
1268 return _s;
1269 }
_internal_lines(int index)1270 inline const std::string& DebuggedSourceFile::_internal_lines(int index) const {
1271 return _impl_.lines_.Get(index);
1272 }
lines(int index)1273 inline const std::string& DebuggedSourceFile::lines(int index) const {
1274 // @@protoc_insertion_point(field_get:tensorflow.DebuggedSourceFile.lines)
1275 return _internal_lines(index);
1276 }
mutable_lines(int index)1277 inline std::string* DebuggedSourceFile::mutable_lines(int index) {
1278 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedSourceFile.lines)
1279 return _impl_.lines_.Mutable(index);
1280 }
set_lines(int index,const std::string & value)1281 inline void DebuggedSourceFile::set_lines(int index, const std::string& value) {
1282 _impl_.lines_.Mutable(index)->assign(value);
1283 // @@protoc_insertion_point(field_set:tensorflow.DebuggedSourceFile.lines)
1284 }
set_lines(int index,std::string && value)1285 inline void DebuggedSourceFile::set_lines(int index, std::string&& value) {
1286 _impl_.lines_.Mutable(index)->assign(std::move(value));
1287 // @@protoc_insertion_point(field_set:tensorflow.DebuggedSourceFile.lines)
1288 }
set_lines(int index,const char * value)1289 inline void DebuggedSourceFile::set_lines(int index, const char* value) {
1290 GOOGLE_DCHECK(value != nullptr);
1291 _impl_.lines_.Mutable(index)->assign(value);
1292 // @@protoc_insertion_point(field_set_char:tensorflow.DebuggedSourceFile.lines)
1293 }
set_lines(int index,const char * value,size_t size)1294 inline void DebuggedSourceFile::set_lines(int index, const char* value, size_t size) {
1295 _impl_.lines_.Mutable(index)->assign(
1296 reinterpret_cast<const char*>(value), size);
1297 // @@protoc_insertion_point(field_set_pointer:tensorflow.DebuggedSourceFile.lines)
1298 }
_internal_add_lines()1299 inline std::string* DebuggedSourceFile::_internal_add_lines() {
1300 return _impl_.lines_.Add();
1301 }
add_lines(const std::string & value)1302 inline void DebuggedSourceFile::add_lines(const std::string& value) {
1303 _impl_.lines_.Add()->assign(value);
1304 // @@protoc_insertion_point(field_add:tensorflow.DebuggedSourceFile.lines)
1305 }
add_lines(std::string && value)1306 inline void DebuggedSourceFile::add_lines(std::string&& value) {
1307 _impl_.lines_.Add(std::move(value));
1308 // @@protoc_insertion_point(field_add:tensorflow.DebuggedSourceFile.lines)
1309 }
add_lines(const char * value)1310 inline void DebuggedSourceFile::add_lines(const char* value) {
1311 GOOGLE_DCHECK(value != nullptr);
1312 _impl_.lines_.Add()->assign(value);
1313 // @@protoc_insertion_point(field_add_char:tensorflow.DebuggedSourceFile.lines)
1314 }
add_lines(const char * value,size_t size)1315 inline void DebuggedSourceFile::add_lines(const char* value, size_t size) {
1316 _impl_.lines_.Add()->assign(reinterpret_cast<const char*>(value), size);
1317 // @@protoc_insertion_point(field_add_pointer:tensorflow.DebuggedSourceFile.lines)
1318 }
1319 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
lines()1320 DebuggedSourceFile::lines() const {
1321 // @@protoc_insertion_point(field_list:tensorflow.DebuggedSourceFile.lines)
1322 return _impl_.lines_;
1323 }
1324 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_lines()1325 DebuggedSourceFile::mutable_lines() {
1326 // @@protoc_insertion_point(field_mutable_list:tensorflow.DebuggedSourceFile.lines)
1327 return &_impl_.lines_;
1328 }
1329
1330 // -------------------------------------------------------------------
1331
1332 // DebuggedSourceFiles
1333
1334 // repeated .tensorflow.DebuggedSourceFile source_files = 1;
_internal_source_files_size()1335 inline int DebuggedSourceFiles::_internal_source_files_size() const {
1336 return _impl_.source_files_.size();
1337 }
source_files_size()1338 inline int DebuggedSourceFiles::source_files_size() const {
1339 return _internal_source_files_size();
1340 }
clear_source_files()1341 inline void DebuggedSourceFiles::clear_source_files() {
1342 _impl_.source_files_.Clear();
1343 }
mutable_source_files(int index)1344 inline ::tensorflow::DebuggedSourceFile* DebuggedSourceFiles::mutable_source_files(int index) {
1345 // @@protoc_insertion_point(field_mutable:tensorflow.DebuggedSourceFiles.source_files)
1346 return _impl_.source_files_.Mutable(index);
1347 }
1348 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebuggedSourceFile >*
mutable_source_files()1349 DebuggedSourceFiles::mutable_source_files() {
1350 // @@protoc_insertion_point(field_mutable_list:tensorflow.DebuggedSourceFiles.source_files)
1351 return &_impl_.source_files_;
1352 }
_internal_source_files(int index)1353 inline const ::tensorflow::DebuggedSourceFile& DebuggedSourceFiles::_internal_source_files(int index) const {
1354 return _impl_.source_files_.Get(index);
1355 }
source_files(int index)1356 inline const ::tensorflow::DebuggedSourceFile& DebuggedSourceFiles::source_files(int index) const {
1357 // @@protoc_insertion_point(field_get:tensorflow.DebuggedSourceFiles.source_files)
1358 return _internal_source_files(index);
1359 }
_internal_add_source_files()1360 inline ::tensorflow::DebuggedSourceFile* DebuggedSourceFiles::_internal_add_source_files() {
1361 return _impl_.source_files_.Add();
1362 }
add_source_files()1363 inline ::tensorflow::DebuggedSourceFile* DebuggedSourceFiles::add_source_files() {
1364 ::tensorflow::DebuggedSourceFile* _add = _internal_add_source_files();
1365 // @@protoc_insertion_point(field_add:tensorflow.DebuggedSourceFiles.source_files)
1366 return _add;
1367 }
1368 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::tensorflow::DebuggedSourceFile >&
source_files()1369 DebuggedSourceFiles::source_files() const {
1370 // @@protoc_insertion_point(field_list:tensorflow.DebuggedSourceFiles.source_files)
1371 return _impl_.source_files_;
1372 }
1373
1374 #ifdef __GNUC__
1375 #pragma GCC diagnostic pop
1376 #endif // __GNUC__
1377 // -------------------------------------------------------------------
1378
1379 // -------------------------------------------------------------------
1380
1381 // -------------------------------------------------------------------
1382
1383
1384 // @@protoc_insertion_point(namespace_scope)
1385
1386 } // namespace tensorflow
1387
1388 // @@protoc_insertion_point(global_scope)
1389
1390 #include <google/protobuf/port_undef.inc>
1391 #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_tensorflow_2fcore_2fprotobuf_2fdebug_2eproto
1392