1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/protobuf/debug.proto
3
4 #include "tensorflow/core/protobuf/debug.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace tensorflow {
DebugTensorWatch(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR DebugTensorWatch::DebugTensorWatch(
23 ::_pbi::ConstantInitialized): _impl_{
24 /*decltype(_impl_.debug_ops_)*/{}
25 , /*decltype(_impl_.debug_urls_)*/{}
26 , /*decltype(_impl_.node_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
27 , /*decltype(_impl_.output_slot_)*/0
28 , /*decltype(_impl_.tolerate_debug_op_creation_failures_)*/false
29 , /*decltype(_impl_._cached_size_)*/{}} {}
30 struct DebugTensorWatchDefaultTypeInternal {
DebugTensorWatchDefaultTypeInternaltensorflow::DebugTensorWatchDefaultTypeInternal31 PROTOBUF_CONSTEXPR DebugTensorWatchDefaultTypeInternal()
32 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugTensorWatchDefaultTypeInternaltensorflow::DebugTensorWatchDefaultTypeInternal33 ~DebugTensorWatchDefaultTypeInternal() {}
34 union { // NOLINT(misc-non-private-member-variables-in-classes)
35 DebugTensorWatch _instance;
36 };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugTensorWatchDefaultTypeInternal _DebugTensorWatch_default_instance_;
DebugOptions(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR DebugOptions::DebugOptions(
40 ::_pbi::ConstantInitialized): _impl_{
41 /*decltype(_impl_.debug_tensor_watch_opts_)*/{}
42 , /*decltype(_impl_.global_step_)*/::int64_t{0}
43 , /*decltype(_impl_.reset_disk_byte_usage_)*/false
44 , /*decltype(_impl_._cached_size_)*/{}} {}
45 struct DebugOptionsDefaultTypeInternal {
DebugOptionsDefaultTypeInternaltensorflow::DebugOptionsDefaultTypeInternal46 PROTOBUF_CONSTEXPR DebugOptionsDefaultTypeInternal()
47 : _instance(::_pbi::ConstantInitialized{}) {}
~DebugOptionsDefaultTypeInternaltensorflow::DebugOptionsDefaultTypeInternal48 ~DebugOptionsDefaultTypeInternal() {}
49 union { // NOLINT(misc-non-private-member-variables-in-classes)
50 DebugOptions _instance;
51 };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebugOptionsDefaultTypeInternal _DebugOptions_default_instance_;
DebuggedSourceFile(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR DebuggedSourceFile::DebuggedSourceFile(
55 ::_pbi::ConstantInitialized): _impl_{
56 /*decltype(_impl_.lines_)*/{}
57 , /*decltype(_impl_.host_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
58 , /*decltype(_impl_.file_path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
59 , /*decltype(_impl_.last_modified_)*/::int64_t{0}
60 , /*decltype(_impl_.bytes_)*/::int64_t{0}
61 , /*decltype(_impl_._cached_size_)*/{}} {}
62 struct DebuggedSourceFileDefaultTypeInternal {
DebuggedSourceFileDefaultTypeInternaltensorflow::DebuggedSourceFileDefaultTypeInternal63 PROTOBUF_CONSTEXPR DebuggedSourceFileDefaultTypeInternal()
64 : _instance(::_pbi::ConstantInitialized{}) {}
~DebuggedSourceFileDefaultTypeInternaltensorflow::DebuggedSourceFileDefaultTypeInternal65 ~DebuggedSourceFileDefaultTypeInternal() {}
66 union { // NOLINT(misc-non-private-member-variables-in-classes)
67 DebuggedSourceFile _instance;
68 };
69 };
70 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebuggedSourceFileDefaultTypeInternal _DebuggedSourceFile_default_instance_;
DebuggedSourceFiles(::_pbi::ConstantInitialized)71 PROTOBUF_CONSTEXPR DebuggedSourceFiles::DebuggedSourceFiles(
72 ::_pbi::ConstantInitialized): _impl_{
73 /*decltype(_impl_.source_files_)*/{}
74 , /*decltype(_impl_._cached_size_)*/{}} {}
75 struct DebuggedSourceFilesDefaultTypeInternal {
DebuggedSourceFilesDefaultTypeInternaltensorflow::DebuggedSourceFilesDefaultTypeInternal76 PROTOBUF_CONSTEXPR DebuggedSourceFilesDefaultTypeInternal()
77 : _instance(::_pbi::ConstantInitialized{}) {}
~DebuggedSourceFilesDefaultTypeInternaltensorflow::DebuggedSourceFilesDefaultTypeInternal78 ~DebuggedSourceFilesDefaultTypeInternal() {}
79 union { // NOLINT(misc-non-private-member-variables-in-classes)
80 DebuggedSourceFiles _instance;
81 };
82 };
83 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DebuggedSourceFilesDefaultTypeInternal _DebuggedSourceFiles_default_instance_;
84 } // namespace tensorflow
85 namespace tensorflow {
86
87 // ===================================================================
88
89 class DebugTensorWatch::_Internal {
90 public:
91 };
92
DebugTensorWatch(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)93 DebugTensorWatch::DebugTensorWatch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
94 bool is_message_owned)
95 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
96 SharedCtor(arena, is_message_owned);
97 // @@protoc_insertion_point(arena_constructor:tensorflow.DebugTensorWatch)
98 }
DebugTensorWatch(const DebugTensorWatch & from)99 DebugTensorWatch::DebugTensorWatch(const DebugTensorWatch& from)
100 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
101 DebugTensorWatch* const _this = this; (void)_this;
102 new (&_impl_) Impl_{
103 decltype(_impl_.debug_ops_){from._impl_.debug_ops_}
104 , decltype(_impl_.debug_urls_){from._impl_.debug_urls_}
105 , decltype(_impl_.node_name_){}
106 , decltype(_impl_.output_slot_){}
107 , decltype(_impl_.tolerate_debug_op_creation_failures_){}
108 , /*decltype(_impl_._cached_size_)*/{}};
109
110 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
111 _impl_.node_name_.InitDefault();
112 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
113 _impl_.node_name_.Set("", GetArenaForAllocation());
114 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
115 if (!from._internal_node_name().empty()) {
116 _this->_impl_.node_name_.Set(from._internal_node_name(),
117 _this->GetArenaForAllocation());
118 }
119 ::memcpy(&_impl_.output_slot_, &from._impl_.output_slot_,
120 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.tolerate_debug_op_creation_failures_) -
121 reinterpret_cast<char*>(&_impl_.output_slot_)) + sizeof(_impl_.tolerate_debug_op_creation_failures_));
122 // @@protoc_insertion_point(copy_constructor:tensorflow.DebugTensorWatch)
123 }
124
SharedCtor(::_pb::Arena * arena,bool is_message_owned)125 inline void DebugTensorWatch::SharedCtor(
126 ::_pb::Arena* arena, bool is_message_owned) {
127 (void)arena;
128 (void)is_message_owned;
129 new (&_impl_) Impl_{
130 decltype(_impl_.debug_ops_){arena}
131 , decltype(_impl_.debug_urls_){arena}
132 , decltype(_impl_.node_name_){}
133 , decltype(_impl_.output_slot_){0}
134 , decltype(_impl_.tolerate_debug_op_creation_failures_){false}
135 , /*decltype(_impl_._cached_size_)*/{}
136 };
137 _impl_.node_name_.InitDefault();
138 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
139 _impl_.node_name_.Set("", GetArenaForAllocation());
140 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
141 }
142
~DebugTensorWatch()143 DebugTensorWatch::~DebugTensorWatch() {
144 // @@protoc_insertion_point(destructor:tensorflow.DebugTensorWatch)
145 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
146 (void)arena;
147 return;
148 }
149 SharedDtor();
150 }
151
SharedDtor()152 inline void DebugTensorWatch::SharedDtor() {
153 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
154 _impl_.debug_ops_.~RepeatedPtrField();
155 _impl_.debug_urls_.~RepeatedPtrField();
156 _impl_.node_name_.Destroy();
157 }
158
SetCachedSize(int size) const159 void DebugTensorWatch::SetCachedSize(int size) const {
160 _impl_._cached_size_.Set(size);
161 }
162
Clear()163 void DebugTensorWatch::Clear() {
164 // @@protoc_insertion_point(message_clear_start:tensorflow.DebugTensorWatch)
165 ::uint32_t cached_has_bits = 0;
166 // Prevent compiler warnings about cached_has_bits being unused
167 (void) cached_has_bits;
168
169 _impl_.debug_ops_.Clear();
170 _impl_.debug_urls_.Clear();
171 _impl_.node_name_.ClearToEmpty();
172 ::memset(&_impl_.output_slot_, 0, static_cast<size_t>(
173 reinterpret_cast<char*>(&_impl_.tolerate_debug_op_creation_failures_) -
174 reinterpret_cast<char*>(&_impl_.output_slot_)) + sizeof(_impl_.tolerate_debug_op_creation_failures_));
175 _internal_metadata_.Clear<std::string>();
176 }
177
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)178 const char* DebugTensorWatch::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
179 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
180 while (!ctx->Done(&ptr)) {
181 ::uint32_t tag;
182 ptr = ::_pbi::ReadTag(ptr, &tag);
183 switch (tag >> 3) {
184 // string node_name = 1;
185 case 1:
186 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
187 auto str = _internal_mutable_node_name();
188 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
189 CHK_(ptr);
190 CHK_(::_pbi::VerifyUTF8(str, nullptr));
191 } else {
192 goto handle_unusual;
193 }
194 continue;
195 // int32 output_slot = 2;
196 case 2:
197 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
198 _impl_.output_slot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
199 CHK_(ptr);
200 } else {
201 goto handle_unusual;
202 }
203 continue;
204 // repeated string debug_ops = 3;
205 case 3:
206 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
207 ptr -= 1;
208 do {
209 ptr += 1;
210 auto str = _internal_add_debug_ops();
211 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
212 CHK_(ptr);
213 CHK_(::_pbi::VerifyUTF8(str, nullptr));
214 if (!ctx->DataAvailable(ptr)) break;
215 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
216 } else {
217 goto handle_unusual;
218 }
219 continue;
220 // repeated string debug_urls = 4;
221 case 4:
222 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
223 ptr -= 1;
224 do {
225 ptr += 1;
226 auto str = _internal_add_debug_urls();
227 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
228 CHK_(ptr);
229 CHK_(::_pbi::VerifyUTF8(str, nullptr));
230 if (!ctx->DataAvailable(ptr)) break;
231 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
232 } else {
233 goto handle_unusual;
234 }
235 continue;
236 // bool tolerate_debug_op_creation_failures = 5;
237 case 5:
238 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
239 _impl_.tolerate_debug_op_creation_failures_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
240 CHK_(ptr);
241 } else {
242 goto handle_unusual;
243 }
244 continue;
245 default:
246 goto handle_unusual;
247 } // switch
248 handle_unusual:
249 if ((tag == 0) || ((tag & 7) == 4)) {
250 CHK_(ptr);
251 ctx->SetLastTag(tag);
252 goto message_done;
253 }
254 ptr = UnknownFieldParse(
255 tag,
256 _internal_metadata_.mutable_unknown_fields<std::string>(),
257 ptr, ctx);
258 CHK_(ptr != nullptr);
259 } // while
260 message_done:
261 return ptr;
262 failure:
263 ptr = nullptr;
264 goto message_done;
265 #undef CHK_
266 }
267
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const268 ::uint8_t* DebugTensorWatch::_InternalSerialize(
269 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
270 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DebugTensorWatch)
271 ::uint32_t cached_has_bits = 0;
272 (void) cached_has_bits;
273
274 // string node_name = 1;
275 if (!this->_internal_node_name().empty()) {
276 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
277 this->_internal_node_name().data(), static_cast<int>(this->_internal_node_name().length()),
278 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
279 "tensorflow.DebugTensorWatch.node_name");
280 target = stream->WriteStringMaybeAliased(
281 1, this->_internal_node_name(), target);
282 }
283
284 // int32 output_slot = 2;
285 if (this->_internal_output_slot() != 0) {
286 target = stream->EnsureSpace(target);
287 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_output_slot(), target);
288 }
289
290 // repeated string debug_ops = 3;
291 for (int i = 0, n = this->_internal_debug_ops_size(); i < n; i++) {
292 const auto& s = this->_internal_debug_ops(i);
293 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
294 s.data(), static_cast<int>(s.length()),
295 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
296 "tensorflow.DebugTensorWatch.debug_ops");
297 target = stream->WriteString(3, s, target);
298 }
299
300 // repeated string debug_urls = 4;
301 for (int i = 0, n = this->_internal_debug_urls_size(); i < n; i++) {
302 const auto& s = this->_internal_debug_urls(i);
303 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
304 s.data(), static_cast<int>(s.length()),
305 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
306 "tensorflow.DebugTensorWatch.debug_urls");
307 target = stream->WriteString(4, s, target);
308 }
309
310 // bool tolerate_debug_op_creation_failures = 5;
311 if (this->_internal_tolerate_debug_op_creation_failures() != 0) {
312 target = stream->EnsureSpace(target);
313 target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_tolerate_debug_op_creation_failures(), target);
314 }
315
316 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
317 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
318 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
319 }
320 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DebugTensorWatch)
321 return target;
322 }
323
ByteSizeLong() const324 size_t DebugTensorWatch::ByteSizeLong() const {
325 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DebugTensorWatch)
326 size_t total_size = 0;
327
328 ::uint32_t cached_has_bits = 0;
329 // Prevent compiler warnings about cached_has_bits being unused
330 (void) cached_has_bits;
331
332 // repeated string debug_ops = 3;
333 total_size += 1 *
334 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.debug_ops_.size());
335 for (int i = 0, n = _impl_.debug_ops_.size(); i < n; i++) {
336 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
337 _impl_.debug_ops_.Get(i));
338 }
339
340 // repeated string debug_urls = 4;
341 total_size += 1 *
342 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.debug_urls_.size());
343 for (int i = 0, n = _impl_.debug_urls_.size(); i < n; i++) {
344 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
345 _impl_.debug_urls_.Get(i));
346 }
347
348 // string node_name = 1;
349 if (!this->_internal_node_name().empty()) {
350 total_size += 1 +
351 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
352 this->_internal_node_name());
353 }
354
355 // int32 output_slot = 2;
356 if (this->_internal_output_slot() != 0) {
357 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_output_slot());
358 }
359
360 // bool tolerate_debug_op_creation_failures = 5;
361 if (this->_internal_tolerate_debug_op_creation_failures() != 0) {
362 total_size += 1 + 1;
363 }
364
365 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
366 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
367 }
368 int cached_size = ::_pbi::ToCachedSize(total_size);
369 SetCachedSize(cached_size);
370 return total_size;
371 }
372
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)373 void DebugTensorWatch::CheckTypeAndMergeFrom(
374 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
375 MergeFrom(*::_pbi::DownCast<const DebugTensorWatch*>(
376 &from));
377 }
378
MergeFrom(const DebugTensorWatch & from)379 void DebugTensorWatch::MergeFrom(const DebugTensorWatch& from) {
380 DebugTensorWatch* const _this = this;
381 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DebugTensorWatch)
382 GOOGLE_DCHECK_NE(&from, _this);
383 ::uint32_t cached_has_bits = 0;
384 (void) cached_has_bits;
385
386 _this->_impl_.debug_ops_.MergeFrom(from._impl_.debug_ops_);
387 _this->_impl_.debug_urls_.MergeFrom(from._impl_.debug_urls_);
388 if (!from._internal_node_name().empty()) {
389 _this->_internal_set_node_name(from._internal_node_name());
390 }
391 if (from._internal_output_slot() != 0) {
392 _this->_internal_set_output_slot(from._internal_output_slot());
393 }
394 if (from._internal_tolerate_debug_op_creation_failures() != 0) {
395 _this->_internal_set_tolerate_debug_op_creation_failures(from._internal_tolerate_debug_op_creation_failures());
396 }
397 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
398 }
399
CopyFrom(const DebugTensorWatch & from)400 void DebugTensorWatch::CopyFrom(const DebugTensorWatch& from) {
401 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DebugTensorWatch)
402 if (&from == this) return;
403 Clear();
404 MergeFrom(from);
405 }
406
IsInitialized() const407 bool DebugTensorWatch::IsInitialized() const {
408 return true;
409 }
410
InternalSwap(DebugTensorWatch * other)411 void DebugTensorWatch::InternalSwap(DebugTensorWatch* other) {
412 using std::swap;
413 auto* lhs_arena = GetArenaForAllocation();
414 auto* rhs_arena = other->GetArenaForAllocation();
415 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
416 _impl_.debug_ops_.InternalSwap(&other->_impl_.debug_ops_);
417 _impl_.debug_urls_.InternalSwap(&other->_impl_.debug_urls_);
418 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
419 &_impl_.node_name_, lhs_arena,
420 &other->_impl_.node_name_, rhs_arena
421 );
422 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
423 PROTOBUF_FIELD_OFFSET(DebugTensorWatch, _impl_.tolerate_debug_op_creation_failures_)
424 + sizeof(DebugTensorWatch::_impl_.tolerate_debug_op_creation_failures_) // NOLINT
425 - PROTOBUF_FIELD_OFFSET(DebugTensorWatch, _impl_.output_slot_)>(
426 reinterpret_cast<char*>(&_impl_.output_slot_),
427 reinterpret_cast<char*>(&other->_impl_.output_slot_));
428 }
429
GetTypeName() const430 std::string DebugTensorWatch::GetTypeName() const {
431 return "tensorflow.DebugTensorWatch";
432 }
433
434
435 // ===================================================================
436
437 class DebugOptions::_Internal {
438 public:
439 };
440
DebugOptions(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)441 DebugOptions::DebugOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
442 bool is_message_owned)
443 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
444 SharedCtor(arena, is_message_owned);
445 // @@protoc_insertion_point(arena_constructor:tensorflow.DebugOptions)
446 }
DebugOptions(const DebugOptions & from)447 DebugOptions::DebugOptions(const DebugOptions& from)
448 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
449 DebugOptions* const _this = this; (void)_this;
450 new (&_impl_) Impl_{
451 decltype(_impl_.debug_tensor_watch_opts_){from._impl_.debug_tensor_watch_opts_}
452 , decltype(_impl_.global_step_){}
453 , decltype(_impl_.reset_disk_byte_usage_){}
454 , /*decltype(_impl_._cached_size_)*/{}};
455
456 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
457 ::memcpy(&_impl_.global_step_, &from._impl_.global_step_,
458 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.reset_disk_byte_usage_) -
459 reinterpret_cast<char*>(&_impl_.global_step_)) + sizeof(_impl_.reset_disk_byte_usage_));
460 // @@protoc_insertion_point(copy_constructor:tensorflow.DebugOptions)
461 }
462
SharedCtor(::_pb::Arena * arena,bool is_message_owned)463 inline void DebugOptions::SharedCtor(
464 ::_pb::Arena* arena, bool is_message_owned) {
465 (void)arena;
466 (void)is_message_owned;
467 new (&_impl_) Impl_{
468 decltype(_impl_.debug_tensor_watch_opts_){arena}
469 , decltype(_impl_.global_step_){::int64_t{0}}
470 , decltype(_impl_.reset_disk_byte_usage_){false}
471 , /*decltype(_impl_._cached_size_)*/{}
472 };
473 }
474
~DebugOptions()475 DebugOptions::~DebugOptions() {
476 // @@protoc_insertion_point(destructor:tensorflow.DebugOptions)
477 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
478 (void)arena;
479 return;
480 }
481 SharedDtor();
482 }
483
SharedDtor()484 inline void DebugOptions::SharedDtor() {
485 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
486 _impl_.debug_tensor_watch_opts_.~RepeatedPtrField();
487 }
488
SetCachedSize(int size) const489 void DebugOptions::SetCachedSize(int size) const {
490 _impl_._cached_size_.Set(size);
491 }
492
Clear()493 void DebugOptions::Clear() {
494 // @@protoc_insertion_point(message_clear_start:tensorflow.DebugOptions)
495 ::uint32_t cached_has_bits = 0;
496 // Prevent compiler warnings about cached_has_bits being unused
497 (void) cached_has_bits;
498
499 _impl_.debug_tensor_watch_opts_.Clear();
500 ::memset(&_impl_.global_step_, 0, static_cast<size_t>(
501 reinterpret_cast<char*>(&_impl_.reset_disk_byte_usage_) -
502 reinterpret_cast<char*>(&_impl_.global_step_)) + sizeof(_impl_.reset_disk_byte_usage_));
503 _internal_metadata_.Clear<std::string>();
504 }
505
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)506 const char* DebugOptions::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
507 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
508 while (!ctx->Done(&ptr)) {
509 ::uint32_t tag;
510 ptr = ::_pbi::ReadTag(ptr, &tag);
511 switch (tag >> 3) {
512 // repeated .tensorflow.DebugTensorWatch debug_tensor_watch_opts = 4;
513 case 4:
514 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
515 ptr -= 1;
516 do {
517 ptr += 1;
518 ptr = ctx->ParseMessage(_internal_add_debug_tensor_watch_opts(), ptr);
519 CHK_(ptr);
520 if (!ctx->DataAvailable(ptr)) break;
521 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
522 } else {
523 goto handle_unusual;
524 }
525 continue;
526 // int64 global_step = 10;
527 case 10:
528 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
529 _impl_.global_step_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
530 CHK_(ptr);
531 } else {
532 goto handle_unusual;
533 }
534 continue;
535 // bool reset_disk_byte_usage = 11;
536 case 11:
537 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
538 _impl_.reset_disk_byte_usage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
539 CHK_(ptr);
540 } else {
541 goto handle_unusual;
542 }
543 continue;
544 default:
545 goto handle_unusual;
546 } // switch
547 handle_unusual:
548 if ((tag == 0) || ((tag & 7) == 4)) {
549 CHK_(ptr);
550 ctx->SetLastTag(tag);
551 goto message_done;
552 }
553 ptr = UnknownFieldParse(
554 tag,
555 _internal_metadata_.mutable_unknown_fields<std::string>(),
556 ptr, ctx);
557 CHK_(ptr != nullptr);
558 } // while
559 message_done:
560 return ptr;
561 failure:
562 ptr = nullptr;
563 goto message_done;
564 #undef CHK_
565 }
566
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const567 ::uint8_t* DebugOptions::_InternalSerialize(
568 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
569 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DebugOptions)
570 ::uint32_t cached_has_bits = 0;
571 (void) cached_has_bits;
572
573 // repeated .tensorflow.DebugTensorWatch debug_tensor_watch_opts = 4;
574 for (unsigned i = 0,
575 n = static_cast<unsigned>(this->_internal_debug_tensor_watch_opts_size()); i < n; i++) {
576 const auto& repfield = this->_internal_debug_tensor_watch_opts(i);
577 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
578 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
579 }
580
581 // int64 global_step = 10;
582 if (this->_internal_global_step() != 0) {
583 target = stream->EnsureSpace(target);
584 target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_global_step(), target);
585 }
586
587 // bool reset_disk_byte_usage = 11;
588 if (this->_internal_reset_disk_byte_usage() != 0) {
589 target = stream->EnsureSpace(target);
590 target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_reset_disk_byte_usage(), target);
591 }
592
593 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
594 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
595 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
596 }
597 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DebugOptions)
598 return target;
599 }
600
ByteSizeLong() const601 size_t DebugOptions::ByteSizeLong() const {
602 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DebugOptions)
603 size_t total_size = 0;
604
605 ::uint32_t cached_has_bits = 0;
606 // Prevent compiler warnings about cached_has_bits being unused
607 (void) cached_has_bits;
608
609 // repeated .tensorflow.DebugTensorWatch debug_tensor_watch_opts = 4;
610 total_size += 1UL * this->_internal_debug_tensor_watch_opts_size();
611 for (const auto& msg : this->_impl_.debug_tensor_watch_opts_) {
612 total_size +=
613 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
614 }
615
616 // int64 global_step = 10;
617 if (this->_internal_global_step() != 0) {
618 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_global_step());
619 }
620
621 // bool reset_disk_byte_usage = 11;
622 if (this->_internal_reset_disk_byte_usage() != 0) {
623 total_size += 1 + 1;
624 }
625
626 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
627 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
628 }
629 int cached_size = ::_pbi::ToCachedSize(total_size);
630 SetCachedSize(cached_size);
631 return total_size;
632 }
633
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)634 void DebugOptions::CheckTypeAndMergeFrom(
635 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
636 MergeFrom(*::_pbi::DownCast<const DebugOptions*>(
637 &from));
638 }
639
MergeFrom(const DebugOptions & from)640 void DebugOptions::MergeFrom(const DebugOptions& from) {
641 DebugOptions* const _this = this;
642 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DebugOptions)
643 GOOGLE_DCHECK_NE(&from, _this);
644 ::uint32_t cached_has_bits = 0;
645 (void) cached_has_bits;
646
647 _this->_impl_.debug_tensor_watch_opts_.MergeFrom(from._impl_.debug_tensor_watch_opts_);
648 if (from._internal_global_step() != 0) {
649 _this->_internal_set_global_step(from._internal_global_step());
650 }
651 if (from._internal_reset_disk_byte_usage() != 0) {
652 _this->_internal_set_reset_disk_byte_usage(from._internal_reset_disk_byte_usage());
653 }
654 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
655 }
656
CopyFrom(const DebugOptions & from)657 void DebugOptions::CopyFrom(const DebugOptions& from) {
658 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DebugOptions)
659 if (&from == this) return;
660 Clear();
661 MergeFrom(from);
662 }
663
IsInitialized() const664 bool DebugOptions::IsInitialized() const {
665 return true;
666 }
667
InternalSwap(DebugOptions * other)668 void DebugOptions::InternalSwap(DebugOptions* other) {
669 using std::swap;
670 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
671 _impl_.debug_tensor_watch_opts_.InternalSwap(&other->_impl_.debug_tensor_watch_opts_);
672 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
673 PROTOBUF_FIELD_OFFSET(DebugOptions, _impl_.reset_disk_byte_usage_)
674 + sizeof(DebugOptions::_impl_.reset_disk_byte_usage_) // NOLINT
675 - PROTOBUF_FIELD_OFFSET(DebugOptions, _impl_.global_step_)>(
676 reinterpret_cast<char*>(&_impl_.global_step_),
677 reinterpret_cast<char*>(&other->_impl_.global_step_));
678 }
679
GetTypeName() const680 std::string DebugOptions::GetTypeName() const {
681 return "tensorflow.DebugOptions";
682 }
683
684
685 // ===================================================================
686
687 class DebuggedSourceFile::_Internal {
688 public:
689 };
690
DebuggedSourceFile(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)691 DebuggedSourceFile::DebuggedSourceFile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
692 bool is_message_owned)
693 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
694 SharedCtor(arena, is_message_owned);
695 // @@protoc_insertion_point(arena_constructor:tensorflow.DebuggedSourceFile)
696 }
DebuggedSourceFile(const DebuggedSourceFile & from)697 DebuggedSourceFile::DebuggedSourceFile(const DebuggedSourceFile& from)
698 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
699 DebuggedSourceFile* const _this = this; (void)_this;
700 new (&_impl_) Impl_{
701 decltype(_impl_.lines_){from._impl_.lines_}
702 , decltype(_impl_.host_){}
703 , decltype(_impl_.file_path_){}
704 , decltype(_impl_.last_modified_){}
705 , decltype(_impl_.bytes_){}
706 , /*decltype(_impl_._cached_size_)*/{}};
707
708 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
709 _impl_.host_.InitDefault();
710 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
711 _impl_.host_.Set("", GetArenaForAllocation());
712 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
713 if (!from._internal_host().empty()) {
714 _this->_impl_.host_.Set(from._internal_host(),
715 _this->GetArenaForAllocation());
716 }
717 _impl_.file_path_.InitDefault();
718 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
719 _impl_.file_path_.Set("", GetArenaForAllocation());
720 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
721 if (!from._internal_file_path().empty()) {
722 _this->_impl_.file_path_.Set(from._internal_file_path(),
723 _this->GetArenaForAllocation());
724 }
725 ::memcpy(&_impl_.last_modified_, &from._impl_.last_modified_,
726 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bytes_) -
727 reinterpret_cast<char*>(&_impl_.last_modified_)) + sizeof(_impl_.bytes_));
728 // @@protoc_insertion_point(copy_constructor:tensorflow.DebuggedSourceFile)
729 }
730
SharedCtor(::_pb::Arena * arena,bool is_message_owned)731 inline void DebuggedSourceFile::SharedCtor(
732 ::_pb::Arena* arena, bool is_message_owned) {
733 (void)arena;
734 (void)is_message_owned;
735 new (&_impl_) Impl_{
736 decltype(_impl_.lines_){arena}
737 , decltype(_impl_.host_){}
738 , decltype(_impl_.file_path_){}
739 , decltype(_impl_.last_modified_){::int64_t{0}}
740 , decltype(_impl_.bytes_){::int64_t{0}}
741 , /*decltype(_impl_._cached_size_)*/{}
742 };
743 _impl_.host_.InitDefault();
744 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
745 _impl_.host_.Set("", GetArenaForAllocation());
746 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
747 _impl_.file_path_.InitDefault();
748 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
749 _impl_.file_path_.Set("", GetArenaForAllocation());
750 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
751 }
752
~DebuggedSourceFile()753 DebuggedSourceFile::~DebuggedSourceFile() {
754 // @@protoc_insertion_point(destructor:tensorflow.DebuggedSourceFile)
755 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
756 (void)arena;
757 return;
758 }
759 SharedDtor();
760 }
761
SharedDtor()762 inline void DebuggedSourceFile::SharedDtor() {
763 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
764 _impl_.lines_.~RepeatedPtrField();
765 _impl_.host_.Destroy();
766 _impl_.file_path_.Destroy();
767 }
768
SetCachedSize(int size) const769 void DebuggedSourceFile::SetCachedSize(int size) const {
770 _impl_._cached_size_.Set(size);
771 }
772
Clear()773 void DebuggedSourceFile::Clear() {
774 // @@protoc_insertion_point(message_clear_start:tensorflow.DebuggedSourceFile)
775 ::uint32_t cached_has_bits = 0;
776 // Prevent compiler warnings about cached_has_bits being unused
777 (void) cached_has_bits;
778
779 _impl_.lines_.Clear();
780 _impl_.host_.ClearToEmpty();
781 _impl_.file_path_.ClearToEmpty();
782 ::memset(&_impl_.last_modified_, 0, static_cast<size_t>(
783 reinterpret_cast<char*>(&_impl_.bytes_) -
784 reinterpret_cast<char*>(&_impl_.last_modified_)) + sizeof(_impl_.bytes_));
785 _internal_metadata_.Clear<std::string>();
786 }
787
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)788 const char* DebuggedSourceFile::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
789 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
790 while (!ctx->Done(&ptr)) {
791 ::uint32_t tag;
792 ptr = ::_pbi::ReadTag(ptr, &tag);
793 switch (tag >> 3) {
794 // string host = 1;
795 case 1:
796 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
797 auto str = _internal_mutable_host();
798 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
799 CHK_(ptr);
800 CHK_(::_pbi::VerifyUTF8(str, nullptr));
801 } else {
802 goto handle_unusual;
803 }
804 continue;
805 // string file_path = 2;
806 case 2:
807 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
808 auto str = _internal_mutable_file_path();
809 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
810 CHK_(ptr);
811 CHK_(::_pbi::VerifyUTF8(str, nullptr));
812 } else {
813 goto handle_unusual;
814 }
815 continue;
816 // int64 last_modified = 3;
817 case 3:
818 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
819 _impl_.last_modified_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
820 CHK_(ptr);
821 } else {
822 goto handle_unusual;
823 }
824 continue;
825 // int64 bytes = 4;
826 case 4:
827 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
828 _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
829 CHK_(ptr);
830 } else {
831 goto handle_unusual;
832 }
833 continue;
834 // repeated string lines = 5;
835 case 5:
836 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
837 ptr -= 1;
838 do {
839 ptr += 1;
840 auto str = _internal_add_lines();
841 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
842 CHK_(ptr);
843 CHK_(::_pbi::VerifyUTF8(str, nullptr));
844 if (!ctx->DataAvailable(ptr)) break;
845 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
846 } else {
847 goto handle_unusual;
848 }
849 continue;
850 default:
851 goto handle_unusual;
852 } // switch
853 handle_unusual:
854 if ((tag == 0) || ((tag & 7) == 4)) {
855 CHK_(ptr);
856 ctx->SetLastTag(tag);
857 goto message_done;
858 }
859 ptr = UnknownFieldParse(
860 tag,
861 _internal_metadata_.mutable_unknown_fields<std::string>(),
862 ptr, ctx);
863 CHK_(ptr != nullptr);
864 } // while
865 message_done:
866 return ptr;
867 failure:
868 ptr = nullptr;
869 goto message_done;
870 #undef CHK_
871 }
872
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const873 ::uint8_t* DebuggedSourceFile::_InternalSerialize(
874 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
875 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DebuggedSourceFile)
876 ::uint32_t cached_has_bits = 0;
877 (void) cached_has_bits;
878
879 // string host = 1;
880 if (!this->_internal_host().empty()) {
881 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
882 this->_internal_host().data(), static_cast<int>(this->_internal_host().length()),
883 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
884 "tensorflow.DebuggedSourceFile.host");
885 target = stream->WriteStringMaybeAliased(
886 1, this->_internal_host(), target);
887 }
888
889 // string file_path = 2;
890 if (!this->_internal_file_path().empty()) {
891 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
892 this->_internal_file_path().data(), static_cast<int>(this->_internal_file_path().length()),
893 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
894 "tensorflow.DebuggedSourceFile.file_path");
895 target = stream->WriteStringMaybeAliased(
896 2, this->_internal_file_path(), target);
897 }
898
899 // int64 last_modified = 3;
900 if (this->_internal_last_modified() != 0) {
901 target = stream->EnsureSpace(target);
902 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_last_modified(), target);
903 }
904
905 // int64 bytes = 4;
906 if (this->_internal_bytes() != 0) {
907 target = stream->EnsureSpace(target);
908 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_bytes(), target);
909 }
910
911 // repeated string lines = 5;
912 for (int i = 0, n = this->_internal_lines_size(); i < n; i++) {
913 const auto& s = this->_internal_lines(i);
914 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
915 s.data(), static_cast<int>(s.length()),
916 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
917 "tensorflow.DebuggedSourceFile.lines");
918 target = stream->WriteString(5, s, target);
919 }
920
921 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
922 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
923 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
924 }
925 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DebuggedSourceFile)
926 return target;
927 }
928
ByteSizeLong() const929 size_t DebuggedSourceFile::ByteSizeLong() const {
930 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DebuggedSourceFile)
931 size_t total_size = 0;
932
933 ::uint32_t cached_has_bits = 0;
934 // Prevent compiler warnings about cached_has_bits being unused
935 (void) cached_has_bits;
936
937 // repeated string lines = 5;
938 total_size += 1 *
939 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.lines_.size());
940 for (int i = 0, n = _impl_.lines_.size(); i < n; i++) {
941 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
942 _impl_.lines_.Get(i));
943 }
944
945 // string host = 1;
946 if (!this->_internal_host().empty()) {
947 total_size += 1 +
948 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
949 this->_internal_host());
950 }
951
952 // string file_path = 2;
953 if (!this->_internal_file_path().empty()) {
954 total_size += 1 +
955 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
956 this->_internal_file_path());
957 }
958
959 // int64 last_modified = 3;
960 if (this->_internal_last_modified() != 0) {
961 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_last_modified());
962 }
963
964 // int64 bytes = 4;
965 if (this->_internal_bytes() != 0) {
966 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_bytes());
967 }
968
969 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
970 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
971 }
972 int cached_size = ::_pbi::ToCachedSize(total_size);
973 SetCachedSize(cached_size);
974 return total_size;
975 }
976
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)977 void DebuggedSourceFile::CheckTypeAndMergeFrom(
978 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
979 MergeFrom(*::_pbi::DownCast<const DebuggedSourceFile*>(
980 &from));
981 }
982
MergeFrom(const DebuggedSourceFile & from)983 void DebuggedSourceFile::MergeFrom(const DebuggedSourceFile& from) {
984 DebuggedSourceFile* const _this = this;
985 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DebuggedSourceFile)
986 GOOGLE_DCHECK_NE(&from, _this);
987 ::uint32_t cached_has_bits = 0;
988 (void) cached_has_bits;
989
990 _this->_impl_.lines_.MergeFrom(from._impl_.lines_);
991 if (!from._internal_host().empty()) {
992 _this->_internal_set_host(from._internal_host());
993 }
994 if (!from._internal_file_path().empty()) {
995 _this->_internal_set_file_path(from._internal_file_path());
996 }
997 if (from._internal_last_modified() != 0) {
998 _this->_internal_set_last_modified(from._internal_last_modified());
999 }
1000 if (from._internal_bytes() != 0) {
1001 _this->_internal_set_bytes(from._internal_bytes());
1002 }
1003 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1004 }
1005
CopyFrom(const DebuggedSourceFile & from)1006 void DebuggedSourceFile::CopyFrom(const DebuggedSourceFile& from) {
1007 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DebuggedSourceFile)
1008 if (&from == this) return;
1009 Clear();
1010 MergeFrom(from);
1011 }
1012
IsInitialized() const1013 bool DebuggedSourceFile::IsInitialized() const {
1014 return true;
1015 }
1016
InternalSwap(DebuggedSourceFile * other)1017 void DebuggedSourceFile::InternalSwap(DebuggedSourceFile* other) {
1018 using std::swap;
1019 auto* lhs_arena = GetArenaForAllocation();
1020 auto* rhs_arena = other->GetArenaForAllocation();
1021 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1022 _impl_.lines_.InternalSwap(&other->_impl_.lines_);
1023 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1024 &_impl_.host_, lhs_arena,
1025 &other->_impl_.host_, rhs_arena
1026 );
1027 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1028 &_impl_.file_path_, lhs_arena,
1029 &other->_impl_.file_path_, rhs_arena
1030 );
1031 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1032 PROTOBUF_FIELD_OFFSET(DebuggedSourceFile, _impl_.bytes_)
1033 + sizeof(DebuggedSourceFile::_impl_.bytes_) // NOLINT
1034 - PROTOBUF_FIELD_OFFSET(DebuggedSourceFile, _impl_.last_modified_)>(
1035 reinterpret_cast<char*>(&_impl_.last_modified_),
1036 reinterpret_cast<char*>(&other->_impl_.last_modified_));
1037 }
1038
GetTypeName() const1039 std::string DebuggedSourceFile::GetTypeName() const {
1040 return "tensorflow.DebuggedSourceFile";
1041 }
1042
1043
1044 // ===================================================================
1045
1046 class DebuggedSourceFiles::_Internal {
1047 public:
1048 };
1049
DebuggedSourceFiles(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1050 DebuggedSourceFiles::DebuggedSourceFiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1051 bool is_message_owned)
1052 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1053 SharedCtor(arena, is_message_owned);
1054 // @@protoc_insertion_point(arena_constructor:tensorflow.DebuggedSourceFiles)
1055 }
DebuggedSourceFiles(const DebuggedSourceFiles & from)1056 DebuggedSourceFiles::DebuggedSourceFiles(const DebuggedSourceFiles& from)
1057 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1058 DebuggedSourceFiles* const _this = this; (void)_this;
1059 new (&_impl_) Impl_{
1060 decltype(_impl_.source_files_){from._impl_.source_files_}
1061 , /*decltype(_impl_._cached_size_)*/{}};
1062
1063 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1064 // @@protoc_insertion_point(copy_constructor:tensorflow.DebuggedSourceFiles)
1065 }
1066
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1067 inline void DebuggedSourceFiles::SharedCtor(
1068 ::_pb::Arena* arena, bool is_message_owned) {
1069 (void)arena;
1070 (void)is_message_owned;
1071 new (&_impl_) Impl_{
1072 decltype(_impl_.source_files_){arena}
1073 , /*decltype(_impl_._cached_size_)*/{}
1074 };
1075 }
1076
~DebuggedSourceFiles()1077 DebuggedSourceFiles::~DebuggedSourceFiles() {
1078 // @@protoc_insertion_point(destructor:tensorflow.DebuggedSourceFiles)
1079 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1080 (void)arena;
1081 return;
1082 }
1083 SharedDtor();
1084 }
1085
SharedDtor()1086 inline void DebuggedSourceFiles::SharedDtor() {
1087 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1088 _impl_.source_files_.~RepeatedPtrField();
1089 }
1090
SetCachedSize(int size) const1091 void DebuggedSourceFiles::SetCachedSize(int size) const {
1092 _impl_._cached_size_.Set(size);
1093 }
1094
Clear()1095 void DebuggedSourceFiles::Clear() {
1096 // @@protoc_insertion_point(message_clear_start:tensorflow.DebuggedSourceFiles)
1097 ::uint32_t cached_has_bits = 0;
1098 // Prevent compiler warnings about cached_has_bits being unused
1099 (void) cached_has_bits;
1100
1101 _impl_.source_files_.Clear();
1102 _internal_metadata_.Clear<std::string>();
1103 }
1104
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1105 const char* DebuggedSourceFiles::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1106 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1107 while (!ctx->Done(&ptr)) {
1108 ::uint32_t tag;
1109 ptr = ::_pbi::ReadTag(ptr, &tag);
1110 switch (tag >> 3) {
1111 // repeated .tensorflow.DebuggedSourceFile source_files = 1;
1112 case 1:
1113 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1114 ptr -= 1;
1115 do {
1116 ptr += 1;
1117 ptr = ctx->ParseMessage(_internal_add_source_files(), ptr);
1118 CHK_(ptr);
1119 if (!ctx->DataAvailable(ptr)) break;
1120 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1121 } else {
1122 goto handle_unusual;
1123 }
1124 continue;
1125 default:
1126 goto handle_unusual;
1127 } // switch
1128 handle_unusual:
1129 if ((tag == 0) || ((tag & 7) == 4)) {
1130 CHK_(ptr);
1131 ctx->SetLastTag(tag);
1132 goto message_done;
1133 }
1134 ptr = UnknownFieldParse(
1135 tag,
1136 _internal_metadata_.mutable_unknown_fields<std::string>(),
1137 ptr, ctx);
1138 CHK_(ptr != nullptr);
1139 } // while
1140 message_done:
1141 return ptr;
1142 failure:
1143 ptr = nullptr;
1144 goto message_done;
1145 #undef CHK_
1146 }
1147
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1148 ::uint8_t* DebuggedSourceFiles::_InternalSerialize(
1149 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1150 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DebuggedSourceFiles)
1151 ::uint32_t cached_has_bits = 0;
1152 (void) cached_has_bits;
1153
1154 // repeated .tensorflow.DebuggedSourceFile source_files = 1;
1155 for (unsigned i = 0,
1156 n = static_cast<unsigned>(this->_internal_source_files_size()); i < n; i++) {
1157 const auto& repfield = this->_internal_source_files(i);
1158 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1159 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1160 }
1161
1162 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1163 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1164 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1165 }
1166 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DebuggedSourceFiles)
1167 return target;
1168 }
1169
ByteSizeLong() const1170 size_t DebuggedSourceFiles::ByteSizeLong() const {
1171 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DebuggedSourceFiles)
1172 size_t total_size = 0;
1173
1174 ::uint32_t cached_has_bits = 0;
1175 // Prevent compiler warnings about cached_has_bits being unused
1176 (void) cached_has_bits;
1177
1178 // repeated .tensorflow.DebuggedSourceFile source_files = 1;
1179 total_size += 1UL * this->_internal_source_files_size();
1180 for (const auto& msg : this->_impl_.source_files_) {
1181 total_size +=
1182 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1183 }
1184
1185 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1186 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1187 }
1188 int cached_size = ::_pbi::ToCachedSize(total_size);
1189 SetCachedSize(cached_size);
1190 return total_size;
1191 }
1192
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1193 void DebuggedSourceFiles::CheckTypeAndMergeFrom(
1194 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1195 MergeFrom(*::_pbi::DownCast<const DebuggedSourceFiles*>(
1196 &from));
1197 }
1198
MergeFrom(const DebuggedSourceFiles & from)1199 void DebuggedSourceFiles::MergeFrom(const DebuggedSourceFiles& from) {
1200 DebuggedSourceFiles* const _this = this;
1201 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DebuggedSourceFiles)
1202 GOOGLE_DCHECK_NE(&from, _this);
1203 ::uint32_t cached_has_bits = 0;
1204 (void) cached_has_bits;
1205
1206 _this->_impl_.source_files_.MergeFrom(from._impl_.source_files_);
1207 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1208 }
1209
CopyFrom(const DebuggedSourceFiles & from)1210 void DebuggedSourceFiles::CopyFrom(const DebuggedSourceFiles& from) {
1211 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DebuggedSourceFiles)
1212 if (&from == this) return;
1213 Clear();
1214 MergeFrom(from);
1215 }
1216
IsInitialized() const1217 bool DebuggedSourceFiles::IsInitialized() const {
1218 return true;
1219 }
1220
InternalSwap(DebuggedSourceFiles * other)1221 void DebuggedSourceFiles::InternalSwap(DebuggedSourceFiles* other) {
1222 using std::swap;
1223 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1224 _impl_.source_files_.InternalSwap(&other->_impl_.source_files_);
1225 }
1226
GetTypeName() const1227 std::string DebuggedSourceFiles::GetTypeName() const {
1228 return "tensorflow.DebuggedSourceFiles";
1229 }
1230
1231
1232 // @@protoc_insertion_point(namespace_scope)
1233 } // namespace tensorflow
1234 PROTOBUF_NAMESPACE_OPEN
1235 template<> PROTOBUF_NOINLINE ::tensorflow::DebugTensorWatch*
CreateMaybeMessage(Arena * arena)1236 Arena::CreateMaybeMessage< ::tensorflow::DebugTensorWatch >(Arena* arena) {
1237 return Arena::CreateMessageInternal< ::tensorflow::DebugTensorWatch >(arena);
1238 }
1239 template<> PROTOBUF_NOINLINE ::tensorflow::DebugOptions*
CreateMaybeMessage(Arena * arena)1240 Arena::CreateMaybeMessage< ::tensorflow::DebugOptions >(Arena* arena) {
1241 return Arena::CreateMessageInternal< ::tensorflow::DebugOptions >(arena);
1242 }
1243 template<> PROTOBUF_NOINLINE ::tensorflow::DebuggedSourceFile*
CreateMaybeMessage(Arena * arena)1244 Arena::CreateMaybeMessage< ::tensorflow::DebuggedSourceFile >(Arena* arena) {
1245 return Arena::CreateMessageInternal< ::tensorflow::DebuggedSourceFile >(arena);
1246 }
1247 template<> PROTOBUF_NOINLINE ::tensorflow::DebuggedSourceFiles*
CreateMaybeMessage(Arena * arena)1248 Arena::CreateMaybeMessage< ::tensorflow::DebuggedSourceFiles >(Arena* arena) {
1249 return Arena::CreateMessageInternal< ::tensorflow::DebuggedSourceFiles >(arena);
1250 }
1251 PROTOBUF_NAMESPACE_CLOSE
1252
1253 // @@protoc_insertion_point(global_scope)
1254 #include <google/protobuf/port_undef.inc>
1255