1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: tensorflow/core/protobuf/status.proto
3 
4 #include "tensorflow/core/protobuf/status.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 {
DerivedStatus(::_pbi::ConstantInitialized)22 PROTOBUF_CONSTEXPR DerivedStatus::DerivedStatus(
23     ::_pbi::ConstantInitialized): _impl_{
24     /*decltype(_impl_._cached_size_)*/{}} {}
25 struct DerivedStatusDefaultTypeInternal {
DerivedStatusDefaultTypeInternaltensorflow::DerivedStatusDefaultTypeInternal26   PROTOBUF_CONSTEXPR DerivedStatusDefaultTypeInternal()
27       : _instance(::_pbi::ConstantInitialized{}) {}
~DerivedStatusDefaultTypeInternaltensorflow::DerivedStatusDefaultTypeInternal28   ~DerivedStatusDefaultTypeInternal() {}
29   union {  // NOLINT(misc-non-private-member-variables-in-classes)
30     DerivedStatus _instance;
31   };
32 };
33 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DerivedStatusDefaultTypeInternal _DerivedStatus_default_instance_;
StackTracePayload_StackFrame(::_pbi::ConstantInitialized)34 PROTOBUF_CONSTEXPR StackTracePayload_StackFrame::StackTracePayload_StackFrame(
35     ::_pbi::ConstantInitialized): _impl_{
36     /*decltype(_impl_.file_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
37   , /*decltype(_impl_.function_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
38   , /*decltype(_impl_.line_number_)*/0
39   , /*decltype(_impl_._cached_size_)*/{}} {}
40 struct StackTracePayload_StackFrameDefaultTypeInternal {
StackTracePayload_StackFrameDefaultTypeInternaltensorflow::StackTracePayload_StackFrameDefaultTypeInternal41   PROTOBUF_CONSTEXPR StackTracePayload_StackFrameDefaultTypeInternal()
42       : _instance(::_pbi::ConstantInitialized{}) {}
~StackTracePayload_StackFrameDefaultTypeInternaltensorflow::StackTracePayload_StackFrameDefaultTypeInternal43   ~StackTracePayload_StackFrameDefaultTypeInternal() {}
44   union {  // NOLINT(misc-non-private-member-variables-in-classes)
45     StackTracePayload_StackFrame _instance;
46   };
47 };
48 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StackTracePayload_StackFrameDefaultTypeInternal _StackTracePayload_StackFrame_default_instance_;
StackTracePayload(::_pbi::ConstantInitialized)49 PROTOBUF_CONSTEXPR StackTracePayload::StackTracePayload(
50     ::_pbi::ConstantInitialized): _impl_{
51     /*decltype(_impl_.stack_frames_)*/{}
52   , /*decltype(_impl_._cached_size_)*/{}} {}
53 struct StackTracePayloadDefaultTypeInternal {
StackTracePayloadDefaultTypeInternaltensorflow::StackTracePayloadDefaultTypeInternal54   PROTOBUF_CONSTEXPR StackTracePayloadDefaultTypeInternal()
55       : _instance(::_pbi::ConstantInitialized{}) {}
~StackTracePayloadDefaultTypeInternaltensorflow::StackTracePayloadDefaultTypeInternal56   ~StackTracePayloadDefaultTypeInternal() {}
57   union {  // NOLINT(misc-non-private-member-variables-in-classes)
58     StackTracePayload _instance;
59   };
60 };
61 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StackTracePayloadDefaultTypeInternal _StackTracePayload_default_instance_;
62 }  // namespace tensorflow
63 namespace tensorflow {
64 
65 // ===================================================================
66 
67 class DerivedStatus::_Internal {
68  public:
69 };
70 
DerivedStatus(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)71 DerivedStatus::DerivedStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
72                          bool is_message_owned)
73   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
74   SharedCtor(arena, is_message_owned);
75   // @@protoc_insertion_point(arena_constructor:tensorflow.DerivedStatus)
76 }
DerivedStatus(const DerivedStatus & from)77 DerivedStatus::DerivedStatus(const DerivedStatus& from)
78   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
79   DerivedStatus* const _this = this; (void)_this;
80   new (&_impl_) Impl_{
81       /*decltype(_impl_._cached_size_)*/{}};
82 
83   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
84   // @@protoc_insertion_point(copy_constructor:tensorflow.DerivedStatus)
85 }
86 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)87 inline void DerivedStatus::SharedCtor(
88     ::_pb::Arena* arena, bool is_message_owned) {
89   (void)arena;
90   (void)is_message_owned;
91   new (&_impl_) Impl_{
92       /*decltype(_impl_._cached_size_)*/{}
93   };
94 }
95 
~DerivedStatus()96 DerivedStatus::~DerivedStatus() {
97   // @@protoc_insertion_point(destructor:tensorflow.DerivedStatus)
98   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
99   (void)arena;
100     return;
101   }
102   SharedDtor();
103 }
104 
SharedDtor()105 inline void DerivedStatus::SharedDtor() {
106   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
107 }
108 
SetCachedSize(int size) const109 void DerivedStatus::SetCachedSize(int size) const {
110   _impl_._cached_size_.Set(size);
111 }
112 
Clear()113 void DerivedStatus::Clear() {
114 // @@protoc_insertion_point(message_clear_start:tensorflow.DerivedStatus)
115   ::uint32_t cached_has_bits = 0;
116   // Prevent compiler warnings about cached_has_bits being unused
117   (void) cached_has_bits;
118 
119   _internal_metadata_.Clear<std::string>();
120 }
121 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)122 const char* DerivedStatus::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
123 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
124   while (!ctx->Done(&ptr)) {
125     ::uint32_t tag;
126     ptr = ::_pbi::ReadTag(ptr, &tag);
127     if ((tag == 0) || ((tag & 7) == 4)) {
128       CHK_(ptr);
129       ctx->SetLastTag(tag);
130       goto message_done;
131     }
132     ptr = UnknownFieldParse(
133         tag,
134         _internal_metadata_.mutable_unknown_fields<std::string>(),
135         ptr, ctx);
136     CHK_(ptr != nullptr);
137   }  // while
138 message_done:
139   return ptr;
140 failure:
141   ptr = nullptr;
142   goto message_done;
143 #undef CHK_
144 }
145 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const146 ::uint8_t* DerivedStatus::_InternalSerialize(
147     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
148   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.DerivedStatus)
149   ::uint32_t cached_has_bits = 0;
150   (void) cached_has_bits;
151 
152   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
153     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
154         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
155   }
156   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.DerivedStatus)
157   return target;
158 }
159 
ByteSizeLong() const160 size_t DerivedStatus::ByteSizeLong() const {
161 // @@protoc_insertion_point(message_byte_size_start:tensorflow.DerivedStatus)
162   size_t total_size = 0;
163 
164   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
165     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
166   }
167   int cached_size = ::_pbi::ToCachedSize(total_size);
168   SetCachedSize(cached_size);
169   return total_size;
170 }
171 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)172 void DerivedStatus::CheckTypeAndMergeFrom(
173     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
174   MergeFrom(*::_pbi::DownCast<const DerivedStatus*>(
175       &from));
176 }
177 
MergeFrom(const DerivedStatus & from)178 void DerivedStatus::MergeFrom(const DerivedStatus& from) {
179   DerivedStatus* const _this = this;
180   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.DerivedStatus)
181   GOOGLE_DCHECK_NE(&from, _this);
182   ::uint32_t cached_has_bits = 0;
183   (void) cached_has_bits;
184 
185   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
186 }
187 
CopyFrom(const DerivedStatus & from)188 void DerivedStatus::CopyFrom(const DerivedStatus& from) {
189 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.DerivedStatus)
190   if (&from == this) return;
191   Clear();
192   MergeFrom(from);
193 }
194 
IsInitialized() const195 bool DerivedStatus::IsInitialized() const {
196   return true;
197 }
198 
InternalSwap(DerivedStatus * other)199 void DerivedStatus::InternalSwap(DerivedStatus* other) {
200   using std::swap;
201   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
202 }
203 
GetTypeName() const204 std::string DerivedStatus::GetTypeName() const {
205   return "tensorflow.DerivedStatus";
206 }
207 
208 
209 // ===================================================================
210 
211 class StackTracePayload_StackFrame::_Internal {
212  public:
213 };
214 
StackTracePayload_StackFrame(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)215 StackTracePayload_StackFrame::StackTracePayload_StackFrame(::PROTOBUF_NAMESPACE_ID::Arena* arena,
216                          bool is_message_owned)
217   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
218   SharedCtor(arena, is_message_owned);
219   // @@protoc_insertion_point(arena_constructor:tensorflow.StackTracePayload.StackFrame)
220 }
StackTracePayload_StackFrame(const StackTracePayload_StackFrame & from)221 StackTracePayload_StackFrame::StackTracePayload_StackFrame(const StackTracePayload_StackFrame& from)
222   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
223   StackTracePayload_StackFrame* const _this = this; (void)_this;
224   new (&_impl_) Impl_{
225       decltype(_impl_.file_name_){}
226     , decltype(_impl_.function_name_){}
227     , decltype(_impl_.line_number_){}
228     , /*decltype(_impl_._cached_size_)*/{}};
229 
230   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
231   _impl_.file_name_.InitDefault();
232   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
233     _impl_.file_name_.Set("", GetArenaForAllocation());
234   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
235   if (!from._internal_file_name().empty()) {
236     _this->_impl_.file_name_.Set(from._internal_file_name(),
237       _this->GetArenaForAllocation());
238   }
239   _impl_.function_name_.InitDefault();
240   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
241     _impl_.function_name_.Set("", GetArenaForAllocation());
242   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
243   if (!from._internal_function_name().empty()) {
244     _this->_impl_.function_name_.Set(from._internal_function_name(),
245       _this->GetArenaForAllocation());
246   }
247   _this->_impl_.line_number_ = from._impl_.line_number_;
248   // @@protoc_insertion_point(copy_constructor:tensorflow.StackTracePayload.StackFrame)
249 }
250 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)251 inline void StackTracePayload_StackFrame::SharedCtor(
252     ::_pb::Arena* arena, bool is_message_owned) {
253   (void)arena;
254   (void)is_message_owned;
255   new (&_impl_) Impl_{
256       decltype(_impl_.file_name_){}
257     , decltype(_impl_.function_name_){}
258     , decltype(_impl_.line_number_){0}
259     , /*decltype(_impl_._cached_size_)*/{}
260   };
261   _impl_.file_name_.InitDefault();
262   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
263     _impl_.file_name_.Set("", GetArenaForAllocation());
264   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
265   _impl_.function_name_.InitDefault();
266   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
267     _impl_.function_name_.Set("", GetArenaForAllocation());
268   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
269 }
270 
~StackTracePayload_StackFrame()271 StackTracePayload_StackFrame::~StackTracePayload_StackFrame() {
272   // @@protoc_insertion_point(destructor:tensorflow.StackTracePayload.StackFrame)
273   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
274   (void)arena;
275     return;
276   }
277   SharedDtor();
278 }
279 
SharedDtor()280 inline void StackTracePayload_StackFrame::SharedDtor() {
281   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
282   _impl_.file_name_.Destroy();
283   _impl_.function_name_.Destroy();
284 }
285 
SetCachedSize(int size) const286 void StackTracePayload_StackFrame::SetCachedSize(int size) const {
287   _impl_._cached_size_.Set(size);
288 }
289 
Clear()290 void StackTracePayload_StackFrame::Clear() {
291 // @@protoc_insertion_point(message_clear_start:tensorflow.StackTracePayload.StackFrame)
292   ::uint32_t cached_has_bits = 0;
293   // Prevent compiler warnings about cached_has_bits being unused
294   (void) cached_has_bits;
295 
296   _impl_.file_name_.ClearToEmpty();
297   _impl_.function_name_.ClearToEmpty();
298   _impl_.line_number_ = 0;
299   _internal_metadata_.Clear<std::string>();
300 }
301 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)302 const char* StackTracePayload_StackFrame::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
303 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
304   while (!ctx->Done(&ptr)) {
305     ::uint32_t tag;
306     ptr = ::_pbi::ReadTag(ptr, &tag);
307     switch (tag >> 3) {
308       // string file_name = 1;
309       case 1:
310         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
311           auto str = _internal_mutable_file_name();
312           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
313           CHK_(ptr);
314           CHK_(::_pbi::VerifyUTF8(str, nullptr));
315         } else {
316           goto handle_unusual;
317         }
318         continue;
319       // int32 line_number = 2;
320       case 2:
321         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
322           _impl_.line_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
323           CHK_(ptr);
324         } else {
325           goto handle_unusual;
326         }
327         continue;
328       // string function_name = 3;
329       case 3:
330         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
331           auto str = _internal_mutable_function_name();
332           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
333           CHK_(ptr);
334           CHK_(::_pbi::VerifyUTF8(str, nullptr));
335         } else {
336           goto handle_unusual;
337         }
338         continue;
339       default:
340         goto handle_unusual;
341     }  // switch
342   handle_unusual:
343     if ((tag == 0) || ((tag & 7) == 4)) {
344       CHK_(ptr);
345       ctx->SetLastTag(tag);
346       goto message_done;
347     }
348     ptr = UnknownFieldParse(
349         tag,
350         _internal_metadata_.mutable_unknown_fields<std::string>(),
351         ptr, ctx);
352     CHK_(ptr != nullptr);
353   }  // while
354 message_done:
355   return ptr;
356 failure:
357   ptr = nullptr;
358   goto message_done;
359 #undef CHK_
360 }
361 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const362 ::uint8_t* StackTracePayload_StackFrame::_InternalSerialize(
363     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
364   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.StackTracePayload.StackFrame)
365   ::uint32_t cached_has_bits = 0;
366   (void) cached_has_bits;
367 
368   // string file_name = 1;
369   if (!this->_internal_file_name().empty()) {
370     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
371       this->_internal_file_name().data(), static_cast<int>(this->_internal_file_name().length()),
372       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
373       "tensorflow.StackTracePayload.StackFrame.file_name");
374     target = stream->WriteStringMaybeAliased(
375         1, this->_internal_file_name(), target);
376   }
377 
378   // int32 line_number = 2;
379   if (this->_internal_line_number() != 0) {
380     target = stream->EnsureSpace(target);
381     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_line_number(), target);
382   }
383 
384   // string function_name = 3;
385   if (!this->_internal_function_name().empty()) {
386     ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
387       this->_internal_function_name().data(), static_cast<int>(this->_internal_function_name().length()),
388       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
389       "tensorflow.StackTracePayload.StackFrame.function_name");
390     target = stream->WriteStringMaybeAliased(
391         3, this->_internal_function_name(), target);
392   }
393 
394   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
395     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
396         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
397   }
398   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.StackTracePayload.StackFrame)
399   return target;
400 }
401 
ByteSizeLong() const402 size_t StackTracePayload_StackFrame::ByteSizeLong() const {
403 // @@protoc_insertion_point(message_byte_size_start:tensorflow.StackTracePayload.StackFrame)
404   size_t total_size = 0;
405 
406   ::uint32_t cached_has_bits = 0;
407   // Prevent compiler warnings about cached_has_bits being unused
408   (void) cached_has_bits;
409 
410   // string file_name = 1;
411   if (!this->_internal_file_name().empty()) {
412     total_size += 1 +
413       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
414         this->_internal_file_name());
415   }
416 
417   // string function_name = 3;
418   if (!this->_internal_function_name().empty()) {
419     total_size += 1 +
420       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
421         this->_internal_function_name());
422   }
423 
424   // int32 line_number = 2;
425   if (this->_internal_line_number() != 0) {
426     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_line_number());
427   }
428 
429   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
430     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
431   }
432   int cached_size = ::_pbi::ToCachedSize(total_size);
433   SetCachedSize(cached_size);
434   return total_size;
435 }
436 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)437 void StackTracePayload_StackFrame::CheckTypeAndMergeFrom(
438     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
439   MergeFrom(*::_pbi::DownCast<const StackTracePayload_StackFrame*>(
440       &from));
441 }
442 
MergeFrom(const StackTracePayload_StackFrame & from)443 void StackTracePayload_StackFrame::MergeFrom(const StackTracePayload_StackFrame& from) {
444   StackTracePayload_StackFrame* const _this = this;
445   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.StackTracePayload.StackFrame)
446   GOOGLE_DCHECK_NE(&from, _this);
447   ::uint32_t cached_has_bits = 0;
448   (void) cached_has_bits;
449 
450   if (!from._internal_file_name().empty()) {
451     _this->_internal_set_file_name(from._internal_file_name());
452   }
453   if (!from._internal_function_name().empty()) {
454     _this->_internal_set_function_name(from._internal_function_name());
455   }
456   if (from._internal_line_number() != 0) {
457     _this->_internal_set_line_number(from._internal_line_number());
458   }
459   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
460 }
461 
CopyFrom(const StackTracePayload_StackFrame & from)462 void StackTracePayload_StackFrame::CopyFrom(const StackTracePayload_StackFrame& from) {
463 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.StackTracePayload.StackFrame)
464   if (&from == this) return;
465   Clear();
466   MergeFrom(from);
467 }
468 
IsInitialized() const469 bool StackTracePayload_StackFrame::IsInitialized() const {
470   return true;
471 }
472 
InternalSwap(StackTracePayload_StackFrame * other)473 void StackTracePayload_StackFrame::InternalSwap(StackTracePayload_StackFrame* other) {
474   using std::swap;
475   auto* lhs_arena = GetArenaForAllocation();
476   auto* rhs_arena = other->GetArenaForAllocation();
477   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
478   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
479       &_impl_.file_name_, lhs_arena,
480       &other->_impl_.file_name_, rhs_arena
481   );
482   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
483       &_impl_.function_name_, lhs_arena,
484       &other->_impl_.function_name_, rhs_arena
485   );
486   swap(_impl_.line_number_, other->_impl_.line_number_);
487 }
488 
GetTypeName() const489 std::string StackTracePayload_StackFrame::GetTypeName() const {
490   return "tensorflow.StackTracePayload.StackFrame";
491 }
492 
493 
494 // ===================================================================
495 
496 class StackTracePayload::_Internal {
497  public:
498 };
499 
StackTracePayload(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)500 StackTracePayload::StackTracePayload(::PROTOBUF_NAMESPACE_ID::Arena* arena,
501                          bool is_message_owned)
502   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
503   SharedCtor(arena, is_message_owned);
504   // @@protoc_insertion_point(arena_constructor:tensorflow.StackTracePayload)
505 }
StackTracePayload(const StackTracePayload & from)506 StackTracePayload::StackTracePayload(const StackTracePayload& from)
507   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
508   StackTracePayload* const _this = this; (void)_this;
509   new (&_impl_) Impl_{
510       decltype(_impl_.stack_frames_){from._impl_.stack_frames_}
511     , /*decltype(_impl_._cached_size_)*/{}};
512 
513   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
514   // @@protoc_insertion_point(copy_constructor:tensorflow.StackTracePayload)
515 }
516 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)517 inline void StackTracePayload::SharedCtor(
518     ::_pb::Arena* arena, bool is_message_owned) {
519   (void)arena;
520   (void)is_message_owned;
521   new (&_impl_) Impl_{
522       decltype(_impl_.stack_frames_){arena}
523     , /*decltype(_impl_._cached_size_)*/{}
524   };
525 }
526 
~StackTracePayload()527 StackTracePayload::~StackTracePayload() {
528   // @@protoc_insertion_point(destructor:tensorflow.StackTracePayload)
529   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
530   (void)arena;
531     return;
532   }
533   SharedDtor();
534 }
535 
SharedDtor()536 inline void StackTracePayload::SharedDtor() {
537   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
538   _impl_.stack_frames_.~RepeatedPtrField();
539 }
540 
SetCachedSize(int size) const541 void StackTracePayload::SetCachedSize(int size) const {
542   _impl_._cached_size_.Set(size);
543 }
544 
Clear()545 void StackTracePayload::Clear() {
546 // @@protoc_insertion_point(message_clear_start:tensorflow.StackTracePayload)
547   ::uint32_t cached_has_bits = 0;
548   // Prevent compiler warnings about cached_has_bits being unused
549   (void) cached_has_bits;
550 
551   _impl_.stack_frames_.Clear();
552   _internal_metadata_.Clear<std::string>();
553 }
554 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)555 const char* StackTracePayload::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
556 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
557   while (!ctx->Done(&ptr)) {
558     ::uint32_t tag;
559     ptr = ::_pbi::ReadTag(ptr, &tag);
560     switch (tag >> 3) {
561       // repeated .tensorflow.StackTracePayload.StackFrame stack_frames = 1;
562       case 1:
563         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
564           ptr -= 1;
565           do {
566             ptr += 1;
567             ptr = ctx->ParseMessage(_internal_add_stack_frames(), ptr);
568             CHK_(ptr);
569             if (!ctx->DataAvailable(ptr)) break;
570           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
571         } else {
572           goto handle_unusual;
573         }
574         continue;
575       default:
576         goto handle_unusual;
577     }  // switch
578   handle_unusual:
579     if ((tag == 0) || ((tag & 7) == 4)) {
580       CHK_(ptr);
581       ctx->SetLastTag(tag);
582       goto message_done;
583     }
584     ptr = UnknownFieldParse(
585         tag,
586         _internal_metadata_.mutable_unknown_fields<std::string>(),
587         ptr, ctx);
588     CHK_(ptr != nullptr);
589   }  // while
590 message_done:
591   return ptr;
592 failure:
593   ptr = nullptr;
594   goto message_done;
595 #undef CHK_
596 }
597 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const598 ::uint8_t* StackTracePayload::_InternalSerialize(
599     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
600   // @@protoc_insertion_point(serialize_to_array_start:tensorflow.StackTracePayload)
601   ::uint32_t cached_has_bits = 0;
602   (void) cached_has_bits;
603 
604   // repeated .tensorflow.StackTracePayload.StackFrame stack_frames = 1;
605   for (unsigned i = 0,
606       n = static_cast<unsigned>(this->_internal_stack_frames_size()); i < n; i++) {
607     const auto& repfield = this->_internal_stack_frames(i);
608     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
609         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
610   }
611 
612   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
613     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
614         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
615   }
616   // @@protoc_insertion_point(serialize_to_array_end:tensorflow.StackTracePayload)
617   return target;
618 }
619 
ByteSizeLong() const620 size_t StackTracePayload::ByteSizeLong() const {
621 // @@protoc_insertion_point(message_byte_size_start:tensorflow.StackTracePayload)
622   size_t total_size = 0;
623 
624   ::uint32_t cached_has_bits = 0;
625   // Prevent compiler warnings about cached_has_bits being unused
626   (void) cached_has_bits;
627 
628   // repeated .tensorflow.StackTracePayload.StackFrame stack_frames = 1;
629   total_size += 1UL * this->_internal_stack_frames_size();
630   for (const auto& msg : this->_impl_.stack_frames_) {
631     total_size +=
632       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
633   }
634 
635   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
636     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
637   }
638   int cached_size = ::_pbi::ToCachedSize(total_size);
639   SetCachedSize(cached_size);
640   return total_size;
641 }
642 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)643 void StackTracePayload::CheckTypeAndMergeFrom(
644     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
645   MergeFrom(*::_pbi::DownCast<const StackTracePayload*>(
646       &from));
647 }
648 
MergeFrom(const StackTracePayload & from)649 void StackTracePayload::MergeFrom(const StackTracePayload& from) {
650   StackTracePayload* const _this = this;
651   // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.StackTracePayload)
652   GOOGLE_DCHECK_NE(&from, _this);
653   ::uint32_t cached_has_bits = 0;
654   (void) cached_has_bits;
655 
656   _this->_impl_.stack_frames_.MergeFrom(from._impl_.stack_frames_);
657   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
658 }
659 
CopyFrom(const StackTracePayload & from)660 void StackTracePayload::CopyFrom(const StackTracePayload& from) {
661 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.StackTracePayload)
662   if (&from == this) return;
663   Clear();
664   MergeFrom(from);
665 }
666 
IsInitialized() const667 bool StackTracePayload::IsInitialized() const {
668   return true;
669 }
670 
InternalSwap(StackTracePayload * other)671 void StackTracePayload::InternalSwap(StackTracePayload* other) {
672   using std::swap;
673   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
674   _impl_.stack_frames_.InternalSwap(&other->_impl_.stack_frames_);
675 }
676 
GetTypeName() const677 std::string StackTracePayload::GetTypeName() const {
678   return "tensorflow.StackTracePayload";
679 }
680 
681 
682 // @@protoc_insertion_point(namespace_scope)
683 }  // namespace tensorflow
684 PROTOBUF_NAMESPACE_OPEN
685 template<> PROTOBUF_NOINLINE ::tensorflow::DerivedStatus*
CreateMaybeMessage(Arena * arena)686 Arena::CreateMaybeMessage< ::tensorflow::DerivedStatus >(Arena* arena) {
687   return Arena::CreateMessageInternal< ::tensorflow::DerivedStatus >(arena);
688 }
689 template<> PROTOBUF_NOINLINE ::tensorflow::StackTracePayload_StackFrame*
CreateMaybeMessage(Arena * arena)690 Arena::CreateMaybeMessage< ::tensorflow::StackTracePayload_StackFrame >(Arena* arena) {
691   return Arena::CreateMessageInternal< ::tensorflow::StackTracePayload_StackFrame >(arena);
692 }
693 template<> PROTOBUF_NOINLINE ::tensorflow::StackTracePayload*
CreateMaybeMessage(Arena * arena)694 Arena::CreateMaybeMessage< ::tensorflow::StackTracePayload >(Arena* arena) {
695   return Arena::CreateMessageInternal< ::tensorflow::StackTracePayload >(arena);
696 }
697 PROTOBUF_NAMESPACE_CLOSE
698 
699 // @@protoc_insertion_point(global_scope)
700 #include <google/protobuf/port_undef.inc>
701