1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: tensorflow/core/profiler/protobuf/xplane.proto
3
4 #include "tensorflow/core/profiler/protobuf/xplane.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 {
22 namespace profiler {
XSpace(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR XSpace::XSpace(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_.planes_)*/{}
26 , /*decltype(_impl_.errors_)*/{}
27 , /*decltype(_impl_.warnings_)*/{}
28 , /*decltype(_impl_.hostnames_)*/{}
29 , /*decltype(_impl_._cached_size_)*/{}} {}
30 struct XSpaceDefaultTypeInternal {
XSpaceDefaultTypeInternaltensorflow::profiler::XSpaceDefaultTypeInternal31 PROTOBUF_CONSTEXPR XSpaceDefaultTypeInternal()
32 : _instance(::_pbi::ConstantInitialized{}) {}
~XSpaceDefaultTypeInternaltensorflow::profiler::XSpaceDefaultTypeInternal33 ~XSpaceDefaultTypeInternal() {}
34 union { // NOLINT(misc-non-private-member-variables-in-classes)
35 XSpace _instance;
36 };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XSpaceDefaultTypeInternal _XSpace_default_instance_;
XPlane_EventMetadataEntry_DoNotUse(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR XPlane_EventMetadataEntry_DoNotUse::XPlane_EventMetadataEntry_DoNotUse(
40 ::_pbi::ConstantInitialized) {}
41 struct XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternal {
XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternaltensorflow::profiler::XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternal42 PROTOBUF_CONSTEXPR XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternal()
43 : _instance(::_pbi::ConstantInitialized{}) {}
~XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternaltensorflow::profiler::XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternal44 ~XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternal() {}
45 union { // NOLINT(misc-non-private-member-variables-in-classes)
46 XPlane_EventMetadataEntry_DoNotUse _instance;
47 };
48 };
49 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XPlane_EventMetadataEntry_DoNotUseDefaultTypeInternal _XPlane_EventMetadataEntry_DoNotUse_default_instance_;
XPlane_StatMetadataEntry_DoNotUse(::_pbi::ConstantInitialized)50 PROTOBUF_CONSTEXPR XPlane_StatMetadataEntry_DoNotUse::XPlane_StatMetadataEntry_DoNotUse(
51 ::_pbi::ConstantInitialized) {}
52 struct XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternal {
XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternaltensorflow::profiler::XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternal53 PROTOBUF_CONSTEXPR XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternal()
54 : _instance(::_pbi::ConstantInitialized{}) {}
~XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternaltensorflow::profiler::XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternal55 ~XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternal() {}
56 union { // NOLINT(misc-non-private-member-variables-in-classes)
57 XPlane_StatMetadataEntry_DoNotUse _instance;
58 };
59 };
60 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XPlane_StatMetadataEntry_DoNotUseDefaultTypeInternal _XPlane_StatMetadataEntry_DoNotUse_default_instance_;
XPlane(::_pbi::ConstantInitialized)61 PROTOBUF_CONSTEXPR XPlane::XPlane(
62 ::_pbi::ConstantInitialized): _impl_{
63 /*decltype(_impl_.lines_)*/{}
64 , /*decltype(_impl_.event_metadata_)*/{}
65 , /*decltype(_impl_.stat_metadata_)*/{}
66 , /*decltype(_impl_.stats_)*/{}
67 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
68 , /*decltype(_impl_.id_)*/::int64_t{0}
69 , /*decltype(_impl_._cached_size_)*/{}} {}
70 struct XPlaneDefaultTypeInternal {
XPlaneDefaultTypeInternaltensorflow::profiler::XPlaneDefaultTypeInternal71 PROTOBUF_CONSTEXPR XPlaneDefaultTypeInternal()
72 : _instance(::_pbi::ConstantInitialized{}) {}
~XPlaneDefaultTypeInternaltensorflow::profiler::XPlaneDefaultTypeInternal73 ~XPlaneDefaultTypeInternal() {}
74 union { // NOLINT(misc-non-private-member-variables-in-classes)
75 XPlane _instance;
76 };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XPlaneDefaultTypeInternal _XPlane_default_instance_;
XLine(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR XLine::XLine(
80 ::_pbi::ConstantInitialized): _impl_{
81 /*decltype(_impl_.events_)*/{}
82 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
83 , /*decltype(_impl_.display_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
84 , /*decltype(_impl_.id_)*/::int64_t{0}
85 , /*decltype(_impl_.timestamp_ns_)*/::int64_t{0}
86 , /*decltype(_impl_.duration_ps_)*/::int64_t{0}
87 , /*decltype(_impl_.display_id_)*/::int64_t{0}
88 , /*decltype(_impl_._cached_size_)*/{}} {}
89 struct XLineDefaultTypeInternal {
XLineDefaultTypeInternaltensorflow::profiler::XLineDefaultTypeInternal90 PROTOBUF_CONSTEXPR XLineDefaultTypeInternal()
91 : _instance(::_pbi::ConstantInitialized{}) {}
~XLineDefaultTypeInternaltensorflow::profiler::XLineDefaultTypeInternal92 ~XLineDefaultTypeInternal() {}
93 union { // NOLINT(misc-non-private-member-variables-in-classes)
94 XLine _instance;
95 };
96 };
97 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XLineDefaultTypeInternal _XLine_default_instance_;
XEvent(::_pbi::ConstantInitialized)98 PROTOBUF_CONSTEXPR XEvent::XEvent(
99 ::_pbi::ConstantInitialized): _impl_{
100 /*decltype(_impl_.stats_)*/{}
101 , /*decltype(_impl_.metadata_id_)*/::int64_t{0}
102 , /*decltype(_impl_.duration_ps_)*/::int64_t{0}
103 , /*decltype(_impl_.data_)*/{}
104 , /*decltype(_impl_._cached_size_)*/{}
105 , /*decltype(_impl_._oneof_case_)*/{}} {}
106 struct XEventDefaultTypeInternal {
XEventDefaultTypeInternaltensorflow::profiler::XEventDefaultTypeInternal107 PROTOBUF_CONSTEXPR XEventDefaultTypeInternal()
108 : _instance(::_pbi::ConstantInitialized{}) {}
~XEventDefaultTypeInternaltensorflow::profiler::XEventDefaultTypeInternal109 ~XEventDefaultTypeInternal() {}
110 union { // NOLINT(misc-non-private-member-variables-in-classes)
111 XEvent _instance;
112 };
113 };
114 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XEventDefaultTypeInternal _XEvent_default_instance_;
XStat(::_pbi::ConstantInitialized)115 PROTOBUF_CONSTEXPR XStat::XStat(
116 ::_pbi::ConstantInitialized): _impl_{
117 /*decltype(_impl_.metadata_id_)*/::int64_t{0}
118 , /*decltype(_impl_.value_)*/{}
119 , /*decltype(_impl_._cached_size_)*/{}
120 , /*decltype(_impl_._oneof_case_)*/{}} {}
121 struct XStatDefaultTypeInternal {
XStatDefaultTypeInternaltensorflow::profiler::XStatDefaultTypeInternal122 PROTOBUF_CONSTEXPR XStatDefaultTypeInternal()
123 : _instance(::_pbi::ConstantInitialized{}) {}
~XStatDefaultTypeInternaltensorflow::profiler::XStatDefaultTypeInternal124 ~XStatDefaultTypeInternal() {}
125 union { // NOLINT(misc-non-private-member-variables-in-classes)
126 XStat _instance;
127 };
128 };
129 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XStatDefaultTypeInternal _XStat_default_instance_;
XEventMetadata(::_pbi::ConstantInitialized)130 PROTOBUF_CONSTEXPR XEventMetadata::XEventMetadata(
131 ::_pbi::ConstantInitialized): _impl_{
132 /*decltype(_impl_.stats_)*/{}
133 , /*decltype(_impl_.child_id_)*/{}
134 , /*decltype(_impl_._child_id_cached_byte_size_)*/{0}
135 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
136 , /*decltype(_impl_.metadata_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
137 , /*decltype(_impl_.display_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
138 , /*decltype(_impl_.id_)*/::int64_t{0}
139 , /*decltype(_impl_._cached_size_)*/{}} {}
140 struct XEventMetadataDefaultTypeInternal {
XEventMetadataDefaultTypeInternaltensorflow::profiler::XEventMetadataDefaultTypeInternal141 PROTOBUF_CONSTEXPR XEventMetadataDefaultTypeInternal()
142 : _instance(::_pbi::ConstantInitialized{}) {}
~XEventMetadataDefaultTypeInternaltensorflow::profiler::XEventMetadataDefaultTypeInternal143 ~XEventMetadataDefaultTypeInternal() {}
144 union { // NOLINT(misc-non-private-member-variables-in-classes)
145 XEventMetadata _instance;
146 };
147 };
148 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XEventMetadataDefaultTypeInternal _XEventMetadata_default_instance_;
XStatMetadata(::_pbi::ConstantInitialized)149 PROTOBUF_CONSTEXPR XStatMetadata::XStatMetadata(
150 ::_pbi::ConstantInitialized): _impl_{
151 /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
152 , /*decltype(_impl_.description_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
153 , /*decltype(_impl_.id_)*/::int64_t{0}
154 , /*decltype(_impl_._cached_size_)*/{}} {}
155 struct XStatMetadataDefaultTypeInternal {
XStatMetadataDefaultTypeInternaltensorflow::profiler::XStatMetadataDefaultTypeInternal156 PROTOBUF_CONSTEXPR XStatMetadataDefaultTypeInternal()
157 : _instance(::_pbi::ConstantInitialized{}) {}
~XStatMetadataDefaultTypeInternaltensorflow::profiler::XStatMetadataDefaultTypeInternal158 ~XStatMetadataDefaultTypeInternal() {}
159 union { // NOLINT(misc-non-private-member-variables-in-classes)
160 XStatMetadata _instance;
161 };
162 };
163 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 XStatMetadataDefaultTypeInternal _XStatMetadata_default_instance_;
164 } // namespace profiler
165 } // namespace tensorflow
166 namespace tensorflow {
167 namespace profiler {
168
169 // ===================================================================
170
171 class XSpace::_Internal {
172 public:
173 };
174
XSpace(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)175 XSpace::XSpace(::PROTOBUF_NAMESPACE_ID::Arena* arena,
176 bool is_message_owned)
177 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
178 SharedCtor(arena, is_message_owned);
179 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XSpace)
180 }
XSpace(const XSpace & from)181 XSpace::XSpace(const XSpace& from)
182 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
183 XSpace* const _this = this; (void)_this;
184 new (&_impl_) Impl_{
185 decltype(_impl_.planes_){from._impl_.planes_}
186 , decltype(_impl_.errors_){from._impl_.errors_}
187 , decltype(_impl_.warnings_){from._impl_.warnings_}
188 , decltype(_impl_.hostnames_){from._impl_.hostnames_}
189 , /*decltype(_impl_._cached_size_)*/{}};
190
191 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
192 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XSpace)
193 }
194
SharedCtor(::_pb::Arena * arena,bool is_message_owned)195 inline void XSpace::SharedCtor(
196 ::_pb::Arena* arena, bool is_message_owned) {
197 (void)arena;
198 (void)is_message_owned;
199 new (&_impl_) Impl_{
200 decltype(_impl_.planes_){arena}
201 , decltype(_impl_.errors_){arena}
202 , decltype(_impl_.warnings_){arena}
203 , decltype(_impl_.hostnames_){arena}
204 , /*decltype(_impl_._cached_size_)*/{}
205 };
206 }
207
~XSpace()208 XSpace::~XSpace() {
209 // @@protoc_insertion_point(destructor:tensorflow.profiler.XSpace)
210 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
211 (void)arena;
212 return;
213 }
214 SharedDtor();
215 }
216
SharedDtor()217 inline void XSpace::SharedDtor() {
218 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
219 _impl_.planes_.~RepeatedPtrField();
220 _impl_.errors_.~RepeatedPtrField();
221 _impl_.warnings_.~RepeatedPtrField();
222 _impl_.hostnames_.~RepeatedPtrField();
223 }
224
SetCachedSize(int size) const225 void XSpace::SetCachedSize(int size) const {
226 _impl_._cached_size_.Set(size);
227 }
228
Clear()229 void XSpace::Clear() {
230 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XSpace)
231 ::uint32_t cached_has_bits = 0;
232 // Prevent compiler warnings about cached_has_bits being unused
233 (void) cached_has_bits;
234
235 _impl_.planes_.Clear();
236 _impl_.errors_.Clear();
237 _impl_.warnings_.Clear();
238 _impl_.hostnames_.Clear();
239 _internal_metadata_.Clear<std::string>();
240 }
241
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)242 const char* XSpace::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
243 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
244 while (!ctx->Done(&ptr)) {
245 ::uint32_t tag;
246 ptr = ::_pbi::ReadTag(ptr, &tag);
247 switch (tag >> 3) {
248 // repeated .tensorflow.profiler.XPlane planes = 1;
249 case 1:
250 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
251 ptr -= 1;
252 do {
253 ptr += 1;
254 ptr = ctx->ParseMessage(_internal_add_planes(), ptr);
255 CHK_(ptr);
256 if (!ctx->DataAvailable(ptr)) break;
257 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
258 } else {
259 goto handle_unusual;
260 }
261 continue;
262 // repeated string errors = 2;
263 case 2:
264 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
265 ptr -= 1;
266 do {
267 ptr += 1;
268 auto str = _internal_add_errors();
269 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
270 CHK_(ptr);
271 CHK_(::_pbi::VerifyUTF8(str, nullptr));
272 if (!ctx->DataAvailable(ptr)) break;
273 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
274 } else {
275 goto handle_unusual;
276 }
277 continue;
278 // repeated string warnings = 3;
279 case 3:
280 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
281 ptr -= 1;
282 do {
283 ptr += 1;
284 auto str = _internal_add_warnings();
285 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
286 CHK_(ptr);
287 CHK_(::_pbi::VerifyUTF8(str, nullptr));
288 if (!ctx->DataAvailable(ptr)) break;
289 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
290 } else {
291 goto handle_unusual;
292 }
293 continue;
294 // repeated string hostnames = 4;
295 case 4:
296 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
297 ptr -= 1;
298 do {
299 ptr += 1;
300 auto str = _internal_add_hostnames();
301 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
302 CHK_(ptr);
303 CHK_(::_pbi::VerifyUTF8(str, nullptr));
304 if (!ctx->DataAvailable(ptr)) break;
305 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
306 } else {
307 goto handle_unusual;
308 }
309 continue;
310 default:
311 goto handle_unusual;
312 } // switch
313 handle_unusual:
314 if ((tag == 0) || ((tag & 7) == 4)) {
315 CHK_(ptr);
316 ctx->SetLastTag(tag);
317 goto message_done;
318 }
319 ptr = UnknownFieldParse(
320 tag,
321 _internal_metadata_.mutable_unknown_fields<std::string>(),
322 ptr, ctx);
323 CHK_(ptr != nullptr);
324 } // while
325 message_done:
326 return ptr;
327 failure:
328 ptr = nullptr;
329 goto message_done;
330 #undef CHK_
331 }
332
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const333 ::uint8_t* XSpace::_InternalSerialize(
334 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
335 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XSpace)
336 ::uint32_t cached_has_bits = 0;
337 (void) cached_has_bits;
338
339 // repeated .tensorflow.profiler.XPlane planes = 1;
340 for (unsigned i = 0,
341 n = static_cast<unsigned>(this->_internal_planes_size()); i < n; i++) {
342 const auto& repfield = this->_internal_planes(i);
343 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
344 InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
345 }
346
347 // repeated string errors = 2;
348 for (int i = 0, n = this->_internal_errors_size(); i < n; i++) {
349 const auto& s = this->_internal_errors(i);
350 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
351 s.data(), static_cast<int>(s.length()),
352 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
353 "tensorflow.profiler.XSpace.errors");
354 target = stream->WriteString(2, s, target);
355 }
356
357 // repeated string warnings = 3;
358 for (int i = 0, n = this->_internal_warnings_size(); i < n; i++) {
359 const auto& s = this->_internal_warnings(i);
360 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
361 s.data(), static_cast<int>(s.length()),
362 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
363 "tensorflow.profiler.XSpace.warnings");
364 target = stream->WriteString(3, s, target);
365 }
366
367 // repeated string hostnames = 4;
368 for (int i = 0, n = this->_internal_hostnames_size(); i < n; i++) {
369 const auto& s = this->_internal_hostnames(i);
370 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
371 s.data(), static_cast<int>(s.length()),
372 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
373 "tensorflow.profiler.XSpace.hostnames");
374 target = stream->WriteString(4, s, target);
375 }
376
377 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
378 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
379 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
380 }
381 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XSpace)
382 return target;
383 }
384
ByteSizeLong() const385 size_t XSpace::ByteSizeLong() const {
386 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XSpace)
387 size_t total_size = 0;
388
389 ::uint32_t cached_has_bits = 0;
390 // Prevent compiler warnings about cached_has_bits being unused
391 (void) cached_has_bits;
392
393 // repeated .tensorflow.profiler.XPlane planes = 1;
394 total_size += 1UL * this->_internal_planes_size();
395 for (const auto& msg : this->_impl_.planes_) {
396 total_size +=
397 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
398 }
399
400 // repeated string errors = 2;
401 total_size += 1 *
402 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.errors_.size());
403 for (int i = 0, n = _impl_.errors_.size(); i < n; i++) {
404 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
405 _impl_.errors_.Get(i));
406 }
407
408 // repeated string warnings = 3;
409 total_size += 1 *
410 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.warnings_.size());
411 for (int i = 0, n = _impl_.warnings_.size(); i < n; i++) {
412 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
413 _impl_.warnings_.Get(i));
414 }
415
416 // repeated string hostnames = 4;
417 total_size += 1 *
418 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.hostnames_.size());
419 for (int i = 0, n = _impl_.hostnames_.size(); i < n; i++) {
420 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
421 _impl_.hostnames_.Get(i));
422 }
423
424 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
425 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
426 }
427 int cached_size = ::_pbi::ToCachedSize(total_size);
428 SetCachedSize(cached_size);
429 return total_size;
430 }
431
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)432 void XSpace::CheckTypeAndMergeFrom(
433 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
434 MergeFrom(*::_pbi::DownCast<const XSpace*>(
435 &from));
436 }
437
MergeFrom(const XSpace & from)438 void XSpace::MergeFrom(const XSpace& from) {
439 XSpace* const _this = this;
440 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XSpace)
441 GOOGLE_DCHECK_NE(&from, _this);
442 ::uint32_t cached_has_bits = 0;
443 (void) cached_has_bits;
444
445 _this->_impl_.planes_.MergeFrom(from._impl_.planes_);
446 _this->_impl_.errors_.MergeFrom(from._impl_.errors_);
447 _this->_impl_.warnings_.MergeFrom(from._impl_.warnings_);
448 _this->_impl_.hostnames_.MergeFrom(from._impl_.hostnames_);
449 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
450 }
451
CopyFrom(const XSpace & from)452 void XSpace::CopyFrom(const XSpace& from) {
453 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XSpace)
454 if (&from == this) return;
455 Clear();
456 MergeFrom(from);
457 }
458
IsInitialized() const459 bool XSpace::IsInitialized() const {
460 return true;
461 }
462
InternalSwap(XSpace * other)463 void XSpace::InternalSwap(XSpace* other) {
464 using std::swap;
465 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
466 _impl_.planes_.InternalSwap(&other->_impl_.planes_);
467 _impl_.errors_.InternalSwap(&other->_impl_.errors_);
468 _impl_.warnings_.InternalSwap(&other->_impl_.warnings_);
469 _impl_.hostnames_.InternalSwap(&other->_impl_.hostnames_);
470 }
471
GetTypeName() const472 std::string XSpace::GetTypeName() const {
473 return "tensorflow.profiler.XSpace";
474 }
475
476
477 // ===================================================================
478
XPlane_EventMetadataEntry_DoNotUse()479 XPlane_EventMetadataEntry_DoNotUse::XPlane_EventMetadataEntry_DoNotUse() {}
XPlane_EventMetadataEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)480 XPlane_EventMetadataEntry_DoNotUse::XPlane_EventMetadataEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
481 : SuperType(arena) {}
MergeFrom(const XPlane_EventMetadataEntry_DoNotUse & other)482 void XPlane_EventMetadataEntry_DoNotUse::MergeFrom(const XPlane_EventMetadataEntry_DoNotUse& other) {
483 MergeFromInternal(other);
484 }
485
486 // ===================================================================
487
XPlane_StatMetadataEntry_DoNotUse()488 XPlane_StatMetadataEntry_DoNotUse::XPlane_StatMetadataEntry_DoNotUse() {}
XPlane_StatMetadataEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena * arena)489 XPlane_StatMetadataEntry_DoNotUse::XPlane_StatMetadataEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena)
490 : SuperType(arena) {}
MergeFrom(const XPlane_StatMetadataEntry_DoNotUse & other)491 void XPlane_StatMetadataEntry_DoNotUse::MergeFrom(const XPlane_StatMetadataEntry_DoNotUse& other) {
492 MergeFromInternal(other);
493 }
494
495 // ===================================================================
496
497 class XPlane::_Internal {
498 public:
499 };
500
XPlane(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)501 XPlane::XPlane(::PROTOBUF_NAMESPACE_ID::Arena* arena,
502 bool is_message_owned)
503 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
504 SharedCtor(arena, is_message_owned);
505 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XPlane)
506 }
XPlane(const XPlane & from)507 XPlane::XPlane(const XPlane& from)
508 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
509 XPlane* const _this = this; (void)_this;
510 new (&_impl_) Impl_{
511 decltype(_impl_.lines_){from._impl_.lines_}
512 , /*decltype(_impl_.event_metadata_)*/{}
513 , /*decltype(_impl_.stat_metadata_)*/{}
514 , decltype(_impl_.stats_){from._impl_.stats_}
515 , decltype(_impl_.name_){}
516 , decltype(_impl_.id_){}
517 , /*decltype(_impl_._cached_size_)*/{}};
518
519 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
520 _this->_impl_.event_metadata_.MergeFrom(from._impl_.event_metadata_);
521 _this->_impl_.stat_metadata_.MergeFrom(from._impl_.stat_metadata_);
522 _impl_.name_.InitDefault();
523 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
524 _impl_.name_.Set("", GetArenaForAllocation());
525 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
526 if (!from._internal_name().empty()) {
527 _this->_impl_.name_.Set(from._internal_name(),
528 _this->GetArenaForAllocation());
529 }
530 _this->_impl_.id_ = from._impl_.id_;
531 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XPlane)
532 }
533
SharedCtor(::_pb::Arena * arena,bool is_message_owned)534 inline void XPlane::SharedCtor(
535 ::_pb::Arena* arena, bool is_message_owned) {
536 (void)arena;
537 (void)is_message_owned;
538 new (&_impl_) Impl_{
539 decltype(_impl_.lines_){arena}
540 , /*decltype(_impl_.event_metadata_)*/{::_pbi::ArenaInitialized(), arena}
541 , /*decltype(_impl_.stat_metadata_)*/{::_pbi::ArenaInitialized(), arena}
542 , decltype(_impl_.stats_){arena}
543 , decltype(_impl_.name_){}
544 , decltype(_impl_.id_){::int64_t{0}}
545 , /*decltype(_impl_._cached_size_)*/{}
546 };
547 _impl_.name_.InitDefault();
548 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
549 _impl_.name_.Set("", GetArenaForAllocation());
550 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
551 }
552
~XPlane()553 XPlane::~XPlane() {
554 // @@protoc_insertion_point(destructor:tensorflow.profiler.XPlane)
555 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
556 (void)arena;
557 return;
558 }
559 SharedDtor();
560 }
561
SharedDtor()562 inline void XPlane::SharedDtor() {
563 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
564 _impl_.lines_.~RepeatedPtrField();
565 _impl_.event_metadata_.Destruct();
566 _impl_.event_metadata_.~MapFieldLite();
567 _impl_.stat_metadata_.Destruct();
568 _impl_.stat_metadata_.~MapFieldLite();
569 _impl_.stats_.~RepeatedPtrField();
570 _impl_.name_.Destroy();
571 }
572
SetCachedSize(int size) const573 void XPlane::SetCachedSize(int size) const {
574 _impl_._cached_size_.Set(size);
575 }
576
Clear()577 void XPlane::Clear() {
578 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XPlane)
579 ::uint32_t cached_has_bits = 0;
580 // Prevent compiler warnings about cached_has_bits being unused
581 (void) cached_has_bits;
582
583 _impl_.lines_.Clear();
584 _impl_.event_metadata_.Clear();
585 _impl_.stat_metadata_.Clear();
586 _impl_.stats_.Clear();
587 _impl_.name_.ClearToEmpty();
588 _impl_.id_ = ::int64_t{0};
589 _internal_metadata_.Clear<std::string>();
590 }
591
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)592 const char* XPlane::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
593 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
594 while (!ctx->Done(&ptr)) {
595 ::uint32_t tag;
596 ptr = ::_pbi::ReadTag(ptr, &tag);
597 switch (tag >> 3) {
598 // int64 id = 1;
599 case 1:
600 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
601 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
602 CHK_(ptr);
603 } else {
604 goto handle_unusual;
605 }
606 continue;
607 // string name = 2;
608 case 2:
609 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
610 auto str = _internal_mutable_name();
611 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
612 CHK_(ptr);
613 CHK_(::_pbi::VerifyUTF8(str, nullptr));
614 } else {
615 goto handle_unusual;
616 }
617 continue;
618 // repeated .tensorflow.profiler.XLine lines = 3;
619 case 3:
620 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
621 ptr -= 1;
622 do {
623 ptr += 1;
624 ptr = ctx->ParseMessage(_internal_add_lines(), ptr);
625 CHK_(ptr);
626 if (!ctx->DataAvailable(ptr)) break;
627 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
628 } else {
629 goto handle_unusual;
630 }
631 continue;
632 // map<int64, .tensorflow.profiler.XEventMetadata> event_metadata = 4;
633 case 4:
634 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
635 ptr -= 1;
636 do {
637 ptr += 1;
638 ptr = ctx->ParseMessage(&_impl_.event_metadata_, ptr);
639 CHK_(ptr);
640 if (!ctx->DataAvailable(ptr)) break;
641 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
642 } else {
643 goto handle_unusual;
644 }
645 continue;
646 // map<int64, .tensorflow.profiler.XStatMetadata> stat_metadata = 5;
647 case 5:
648 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
649 ptr -= 1;
650 do {
651 ptr += 1;
652 ptr = ctx->ParseMessage(&_impl_.stat_metadata_, ptr);
653 CHK_(ptr);
654 if (!ctx->DataAvailable(ptr)) break;
655 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
656 } else {
657 goto handle_unusual;
658 }
659 continue;
660 // repeated .tensorflow.profiler.XStat stats = 6;
661 case 6:
662 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
663 ptr -= 1;
664 do {
665 ptr += 1;
666 ptr = ctx->ParseMessage(_internal_add_stats(), ptr);
667 CHK_(ptr);
668 if (!ctx->DataAvailable(ptr)) break;
669 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
670 } else {
671 goto handle_unusual;
672 }
673 continue;
674 default:
675 goto handle_unusual;
676 } // switch
677 handle_unusual:
678 if ((tag == 0) || ((tag & 7) == 4)) {
679 CHK_(ptr);
680 ctx->SetLastTag(tag);
681 goto message_done;
682 }
683 ptr = UnknownFieldParse(
684 tag,
685 _internal_metadata_.mutable_unknown_fields<std::string>(),
686 ptr, ctx);
687 CHK_(ptr != nullptr);
688 } // while
689 message_done:
690 return ptr;
691 failure:
692 ptr = nullptr;
693 goto message_done;
694 #undef CHK_
695 }
696
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const697 ::uint8_t* XPlane::_InternalSerialize(
698 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
699 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XPlane)
700 ::uint32_t cached_has_bits = 0;
701 (void) cached_has_bits;
702
703 // int64 id = 1;
704 if (this->_internal_id() != 0) {
705 target = stream->EnsureSpace(target);
706 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_id(), target);
707 }
708
709 // string name = 2;
710 if (!this->_internal_name().empty()) {
711 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
712 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
713 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
714 "tensorflow.profiler.XPlane.name");
715 target = stream->WriteStringMaybeAliased(
716 2, this->_internal_name(), target);
717 }
718
719 // repeated .tensorflow.profiler.XLine lines = 3;
720 for (unsigned i = 0,
721 n = static_cast<unsigned>(this->_internal_lines_size()); i < n; i++) {
722 const auto& repfield = this->_internal_lines(i);
723 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
724 InternalWriteMessage(3, repfield, repfield.GetCachedSize(), target, stream);
725 }
726
727 // map<int64, .tensorflow.profiler.XEventMetadata> event_metadata = 4;
728 if (!this->_internal_event_metadata().empty()) {
729 using MapType = ::_pb::Map<::int64_t, ::tensorflow::profiler::XEventMetadata>;
730 using WireHelper = XPlane_EventMetadataEntry_DoNotUse::Funcs;
731 const auto& map_field = this->_internal_event_metadata();
732
733 if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
734 for (const auto& entry : ::_pbi::MapSorterFlat<MapType>(map_field)) {
735 target = WireHelper::InternalSerialize(4, entry.first, entry.second, target, stream);
736 }
737 } else {
738 for (const auto& entry : map_field) {
739 target = WireHelper::InternalSerialize(4, entry.first, entry.second, target, stream);
740 }
741 }
742 }
743
744 // map<int64, .tensorflow.profiler.XStatMetadata> stat_metadata = 5;
745 if (!this->_internal_stat_metadata().empty()) {
746 using MapType = ::_pb::Map<::int64_t, ::tensorflow::profiler::XStatMetadata>;
747 using WireHelper = XPlane_StatMetadataEntry_DoNotUse::Funcs;
748 const auto& map_field = this->_internal_stat_metadata();
749
750 if (stream->IsSerializationDeterministic() && map_field.size() > 1) {
751 for (const auto& entry : ::_pbi::MapSorterFlat<MapType>(map_field)) {
752 target = WireHelper::InternalSerialize(5, entry.first, entry.second, target, stream);
753 }
754 } else {
755 for (const auto& entry : map_field) {
756 target = WireHelper::InternalSerialize(5, entry.first, entry.second, target, stream);
757 }
758 }
759 }
760
761 // repeated .tensorflow.profiler.XStat stats = 6;
762 for (unsigned i = 0,
763 n = static_cast<unsigned>(this->_internal_stats_size()); i < n; i++) {
764 const auto& repfield = this->_internal_stats(i);
765 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
766 InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream);
767 }
768
769 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
770 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
771 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
772 }
773 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XPlane)
774 return target;
775 }
776
ByteSizeLong() const777 size_t XPlane::ByteSizeLong() const {
778 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XPlane)
779 size_t total_size = 0;
780
781 ::uint32_t cached_has_bits = 0;
782 // Prevent compiler warnings about cached_has_bits being unused
783 (void) cached_has_bits;
784
785 // repeated .tensorflow.profiler.XLine lines = 3;
786 total_size += 1UL * this->_internal_lines_size();
787 for (const auto& msg : this->_impl_.lines_) {
788 total_size +=
789 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
790 }
791
792 // map<int64, .tensorflow.profiler.XEventMetadata> event_metadata = 4;
793 total_size += 1 *
794 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_event_metadata_size());
795 for (::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::tensorflow::profiler::XEventMetadata >::const_iterator
796 it = this->_internal_event_metadata().begin();
797 it != this->_internal_event_metadata().end(); ++it) {
798 total_size += XPlane_EventMetadataEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
799 }
800
801 // map<int64, .tensorflow.profiler.XStatMetadata> stat_metadata = 5;
802 total_size += 1 *
803 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(this->_internal_stat_metadata_size());
804 for (::PROTOBUF_NAMESPACE_ID::Map< ::int64_t, ::tensorflow::profiler::XStatMetadata >::const_iterator
805 it = this->_internal_stat_metadata().begin();
806 it != this->_internal_stat_metadata().end(); ++it) {
807 total_size += XPlane_StatMetadataEntry_DoNotUse::Funcs::ByteSizeLong(it->first, it->second);
808 }
809
810 // repeated .tensorflow.profiler.XStat stats = 6;
811 total_size += 1UL * this->_internal_stats_size();
812 for (const auto& msg : this->_impl_.stats_) {
813 total_size +=
814 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
815 }
816
817 // string name = 2;
818 if (!this->_internal_name().empty()) {
819 total_size += 1 +
820 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
821 this->_internal_name());
822 }
823
824 // int64 id = 1;
825 if (this->_internal_id() != 0) {
826 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_id());
827 }
828
829 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
830 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
831 }
832 int cached_size = ::_pbi::ToCachedSize(total_size);
833 SetCachedSize(cached_size);
834 return total_size;
835 }
836
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)837 void XPlane::CheckTypeAndMergeFrom(
838 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
839 MergeFrom(*::_pbi::DownCast<const XPlane*>(
840 &from));
841 }
842
MergeFrom(const XPlane & from)843 void XPlane::MergeFrom(const XPlane& from) {
844 XPlane* const _this = this;
845 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XPlane)
846 GOOGLE_DCHECK_NE(&from, _this);
847 ::uint32_t cached_has_bits = 0;
848 (void) cached_has_bits;
849
850 _this->_impl_.lines_.MergeFrom(from._impl_.lines_);
851 _this->_impl_.event_metadata_.MergeFrom(from._impl_.event_metadata_);
852 _this->_impl_.stat_metadata_.MergeFrom(from._impl_.stat_metadata_);
853 _this->_impl_.stats_.MergeFrom(from._impl_.stats_);
854 if (!from._internal_name().empty()) {
855 _this->_internal_set_name(from._internal_name());
856 }
857 if (from._internal_id() != 0) {
858 _this->_internal_set_id(from._internal_id());
859 }
860 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
861 }
862
CopyFrom(const XPlane & from)863 void XPlane::CopyFrom(const XPlane& from) {
864 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XPlane)
865 if (&from == this) return;
866 Clear();
867 MergeFrom(from);
868 }
869
IsInitialized() const870 bool XPlane::IsInitialized() const {
871 return true;
872 }
873
InternalSwap(XPlane * other)874 void XPlane::InternalSwap(XPlane* other) {
875 using std::swap;
876 auto* lhs_arena = GetArenaForAllocation();
877 auto* rhs_arena = other->GetArenaForAllocation();
878 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
879 _impl_.lines_.InternalSwap(&other->_impl_.lines_);
880 _impl_.event_metadata_.InternalSwap(&other->_impl_.event_metadata_);
881 _impl_.stat_metadata_.InternalSwap(&other->_impl_.stat_metadata_);
882 _impl_.stats_.InternalSwap(&other->_impl_.stats_);
883 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
884 &_impl_.name_, lhs_arena,
885 &other->_impl_.name_, rhs_arena
886 );
887 swap(_impl_.id_, other->_impl_.id_);
888 }
889
GetTypeName() const890 std::string XPlane::GetTypeName() const {
891 return "tensorflow.profiler.XPlane";
892 }
893
894
895 // ===================================================================
896
897 class XLine::_Internal {
898 public:
899 };
900
XLine(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)901 XLine::XLine(::PROTOBUF_NAMESPACE_ID::Arena* arena,
902 bool is_message_owned)
903 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
904 SharedCtor(arena, is_message_owned);
905 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XLine)
906 }
XLine(const XLine & from)907 XLine::XLine(const XLine& from)
908 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
909 XLine* const _this = this; (void)_this;
910 new (&_impl_) Impl_{
911 decltype(_impl_.events_){from._impl_.events_}
912 , decltype(_impl_.name_){}
913 , decltype(_impl_.display_name_){}
914 , decltype(_impl_.id_){}
915 , decltype(_impl_.timestamp_ns_){}
916 , decltype(_impl_.duration_ps_){}
917 , decltype(_impl_.display_id_){}
918 , /*decltype(_impl_._cached_size_)*/{}};
919
920 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
921 _impl_.name_.InitDefault();
922 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
923 _impl_.name_.Set("", GetArenaForAllocation());
924 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
925 if (!from._internal_name().empty()) {
926 _this->_impl_.name_.Set(from._internal_name(),
927 _this->GetArenaForAllocation());
928 }
929 _impl_.display_name_.InitDefault();
930 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
931 _impl_.display_name_.Set("", GetArenaForAllocation());
932 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
933 if (!from._internal_display_name().empty()) {
934 _this->_impl_.display_name_.Set(from._internal_display_name(),
935 _this->GetArenaForAllocation());
936 }
937 ::memcpy(&_impl_.id_, &from._impl_.id_,
938 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.display_id_) -
939 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.display_id_));
940 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XLine)
941 }
942
SharedCtor(::_pb::Arena * arena,bool is_message_owned)943 inline void XLine::SharedCtor(
944 ::_pb::Arena* arena, bool is_message_owned) {
945 (void)arena;
946 (void)is_message_owned;
947 new (&_impl_) Impl_{
948 decltype(_impl_.events_){arena}
949 , decltype(_impl_.name_){}
950 , decltype(_impl_.display_name_){}
951 , decltype(_impl_.id_){::int64_t{0}}
952 , decltype(_impl_.timestamp_ns_){::int64_t{0}}
953 , decltype(_impl_.duration_ps_){::int64_t{0}}
954 , decltype(_impl_.display_id_){::int64_t{0}}
955 , /*decltype(_impl_._cached_size_)*/{}
956 };
957 _impl_.name_.InitDefault();
958 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
959 _impl_.name_.Set("", GetArenaForAllocation());
960 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
961 _impl_.display_name_.InitDefault();
962 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
963 _impl_.display_name_.Set("", GetArenaForAllocation());
964 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
965 }
966
~XLine()967 XLine::~XLine() {
968 // @@protoc_insertion_point(destructor:tensorflow.profiler.XLine)
969 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
970 (void)arena;
971 return;
972 }
973 SharedDtor();
974 }
975
SharedDtor()976 inline void XLine::SharedDtor() {
977 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
978 _impl_.events_.~RepeatedPtrField();
979 _impl_.name_.Destroy();
980 _impl_.display_name_.Destroy();
981 }
982
SetCachedSize(int size) const983 void XLine::SetCachedSize(int size) const {
984 _impl_._cached_size_.Set(size);
985 }
986
Clear()987 void XLine::Clear() {
988 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XLine)
989 ::uint32_t cached_has_bits = 0;
990 // Prevent compiler warnings about cached_has_bits being unused
991 (void) cached_has_bits;
992
993 _impl_.events_.Clear();
994 _impl_.name_.ClearToEmpty();
995 _impl_.display_name_.ClearToEmpty();
996 ::memset(&_impl_.id_, 0, static_cast<size_t>(
997 reinterpret_cast<char*>(&_impl_.display_id_) -
998 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.display_id_));
999 _internal_metadata_.Clear<std::string>();
1000 }
1001
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1002 const char* XLine::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1003 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1004 while (!ctx->Done(&ptr)) {
1005 ::uint32_t tag;
1006 ptr = ::_pbi::ReadTag(ptr, &tag);
1007 switch (tag >> 3) {
1008 // int64 id = 1;
1009 case 1:
1010 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1011 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1012 CHK_(ptr);
1013 } else {
1014 goto handle_unusual;
1015 }
1016 continue;
1017 // string name = 2;
1018 case 2:
1019 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1020 auto str = _internal_mutable_name();
1021 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1022 CHK_(ptr);
1023 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1024 } else {
1025 goto handle_unusual;
1026 }
1027 continue;
1028 // int64 timestamp_ns = 3;
1029 case 3:
1030 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1031 _impl_.timestamp_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1032 CHK_(ptr);
1033 } else {
1034 goto handle_unusual;
1035 }
1036 continue;
1037 // repeated .tensorflow.profiler.XEvent events = 4;
1038 case 4:
1039 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1040 ptr -= 1;
1041 do {
1042 ptr += 1;
1043 ptr = ctx->ParseMessage(_internal_add_events(), ptr);
1044 CHK_(ptr);
1045 if (!ctx->DataAvailable(ptr)) break;
1046 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1047 } else {
1048 goto handle_unusual;
1049 }
1050 continue;
1051 // int64 duration_ps = 9;
1052 case 9:
1053 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1054 _impl_.duration_ps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1055 CHK_(ptr);
1056 } else {
1057 goto handle_unusual;
1058 }
1059 continue;
1060 // int64 display_id = 10;
1061 case 10:
1062 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
1063 _impl_.display_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1064 CHK_(ptr);
1065 } else {
1066 goto handle_unusual;
1067 }
1068 continue;
1069 // string display_name = 11;
1070 case 11:
1071 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) {
1072 auto str = _internal_mutable_display_name();
1073 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1074 CHK_(ptr);
1075 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1076 } else {
1077 goto handle_unusual;
1078 }
1079 continue;
1080 default:
1081 goto handle_unusual;
1082 } // switch
1083 handle_unusual:
1084 if ((tag == 0) || ((tag & 7) == 4)) {
1085 CHK_(ptr);
1086 ctx->SetLastTag(tag);
1087 goto message_done;
1088 }
1089 ptr = UnknownFieldParse(
1090 tag,
1091 _internal_metadata_.mutable_unknown_fields<std::string>(),
1092 ptr, ctx);
1093 CHK_(ptr != nullptr);
1094 } // while
1095 message_done:
1096 return ptr;
1097 failure:
1098 ptr = nullptr;
1099 goto message_done;
1100 #undef CHK_
1101 }
1102
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1103 ::uint8_t* XLine::_InternalSerialize(
1104 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1105 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XLine)
1106 ::uint32_t cached_has_bits = 0;
1107 (void) cached_has_bits;
1108
1109 // int64 id = 1;
1110 if (this->_internal_id() != 0) {
1111 target = stream->EnsureSpace(target);
1112 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_id(), target);
1113 }
1114
1115 // string name = 2;
1116 if (!this->_internal_name().empty()) {
1117 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1118 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
1119 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1120 "tensorflow.profiler.XLine.name");
1121 target = stream->WriteStringMaybeAliased(
1122 2, this->_internal_name(), target);
1123 }
1124
1125 // int64 timestamp_ns = 3;
1126 if (this->_internal_timestamp_ns() != 0) {
1127 target = stream->EnsureSpace(target);
1128 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_timestamp_ns(), target);
1129 }
1130
1131 // repeated .tensorflow.profiler.XEvent events = 4;
1132 for (unsigned i = 0,
1133 n = static_cast<unsigned>(this->_internal_events_size()); i < n; i++) {
1134 const auto& repfield = this->_internal_events(i);
1135 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1136 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
1137 }
1138
1139 // int64 duration_ps = 9;
1140 if (this->_internal_duration_ps() != 0) {
1141 target = stream->EnsureSpace(target);
1142 target = ::_pbi::WireFormatLite::WriteInt64ToArray(9, this->_internal_duration_ps(), target);
1143 }
1144
1145 // int64 display_id = 10;
1146 if (this->_internal_display_id() != 0) {
1147 target = stream->EnsureSpace(target);
1148 target = ::_pbi::WireFormatLite::WriteInt64ToArray(10, this->_internal_display_id(), target);
1149 }
1150
1151 // string display_name = 11;
1152 if (!this->_internal_display_name().empty()) {
1153 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1154 this->_internal_display_name().data(), static_cast<int>(this->_internal_display_name().length()),
1155 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1156 "tensorflow.profiler.XLine.display_name");
1157 target = stream->WriteStringMaybeAliased(
1158 11, this->_internal_display_name(), target);
1159 }
1160
1161 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1162 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1163 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1164 }
1165 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XLine)
1166 return target;
1167 }
1168
ByteSizeLong() const1169 size_t XLine::ByteSizeLong() const {
1170 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XLine)
1171 size_t total_size = 0;
1172
1173 ::uint32_t cached_has_bits = 0;
1174 // Prevent compiler warnings about cached_has_bits being unused
1175 (void) cached_has_bits;
1176
1177 // repeated .tensorflow.profiler.XEvent events = 4;
1178 total_size += 1UL * this->_internal_events_size();
1179 for (const auto& msg : this->_impl_.events_) {
1180 total_size +=
1181 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1182 }
1183
1184 // string name = 2;
1185 if (!this->_internal_name().empty()) {
1186 total_size += 1 +
1187 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1188 this->_internal_name());
1189 }
1190
1191 // string display_name = 11;
1192 if (!this->_internal_display_name().empty()) {
1193 total_size += 1 +
1194 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1195 this->_internal_display_name());
1196 }
1197
1198 // int64 id = 1;
1199 if (this->_internal_id() != 0) {
1200 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_id());
1201 }
1202
1203 // int64 timestamp_ns = 3;
1204 if (this->_internal_timestamp_ns() != 0) {
1205 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_timestamp_ns());
1206 }
1207
1208 // int64 duration_ps = 9;
1209 if (this->_internal_duration_ps() != 0) {
1210 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_duration_ps());
1211 }
1212
1213 // int64 display_id = 10;
1214 if (this->_internal_display_id() != 0) {
1215 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_display_id());
1216 }
1217
1218 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1219 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1220 }
1221 int cached_size = ::_pbi::ToCachedSize(total_size);
1222 SetCachedSize(cached_size);
1223 return total_size;
1224 }
1225
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1226 void XLine::CheckTypeAndMergeFrom(
1227 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1228 MergeFrom(*::_pbi::DownCast<const XLine*>(
1229 &from));
1230 }
1231
MergeFrom(const XLine & from)1232 void XLine::MergeFrom(const XLine& from) {
1233 XLine* const _this = this;
1234 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XLine)
1235 GOOGLE_DCHECK_NE(&from, _this);
1236 ::uint32_t cached_has_bits = 0;
1237 (void) cached_has_bits;
1238
1239 _this->_impl_.events_.MergeFrom(from._impl_.events_);
1240 if (!from._internal_name().empty()) {
1241 _this->_internal_set_name(from._internal_name());
1242 }
1243 if (!from._internal_display_name().empty()) {
1244 _this->_internal_set_display_name(from._internal_display_name());
1245 }
1246 if (from._internal_id() != 0) {
1247 _this->_internal_set_id(from._internal_id());
1248 }
1249 if (from._internal_timestamp_ns() != 0) {
1250 _this->_internal_set_timestamp_ns(from._internal_timestamp_ns());
1251 }
1252 if (from._internal_duration_ps() != 0) {
1253 _this->_internal_set_duration_ps(from._internal_duration_ps());
1254 }
1255 if (from._internal_display_id() != 0) {
1256 _this->_internal_set_display_id(from._internal_display_id());
1257 }
1258 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1259 }
1260
CopyFrom(const XLine & from)1261 void XLine::CopyFrom(const XLine& from) {
1262 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XLine)
1263 if (&from == this) return;
1264 Clear();
1265 MergeFrom(from);
1266 }
1267
IsInitialized() const1268 bool XLine::IsInitialized() const {
1269 return true;
1270 }
1271
InternalSwap(XLine * other)1272 void XLine::InternalSwap(XLine* other) {
1273 using std::swap;
1274 auto* lhs_arena = GetArenaForAllocation();
1275 auto* rhs_arena = other->GetArenaForAllocation();
1276 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1277 _impl_.events_.InternalSwap(&other->_impl_.events_);
1278 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1279 &_impl_.name_, lhs_arena,
1280 &other->_impl_.name_, rhs_arena
1281 );
1282 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1283 &_impl_.display_name_, lhs_arena,
1284 &other->_impl_.display_name_, rhs_arena
1285 );
1286 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1287 PROTOBUF_FIELD_OFFSET(XLine, _impl_.display_id_)
1288 + sizeof(XLine::_impl_.display_id_) // NOLINT
1289 - PROTOBUF_FIELD_OFFSET(XLine, _impl_.id_)>(
1290 reinterpret_cast<char*>(&_impl_.id_),
1291 reinterpret_cast<char*>(&other->_impl_.id_));
1292 }
1293
GetTypeName() const1294 std::string XLine::GetTypeName() const {
1295 return "tensorflow.profiler.XLine";
1296 }
1297
1298
1299 // ===================================================================
1300
1301 class XEvent::_Internal {
1302 public:
1303 };
1304
XEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1305 XEvent::XEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1306 bool is_message_owned)
1307 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1308 SharedCtor(arena, is_message_owned);
1309 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XEvent)
1310 }
XEvent(const XEvent & from)1311 XEvent::XEvent(const XEvent& from)
1312 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1313 XEvent* const _this = this; (void)_this;
1314 new (&_impl_) Impl_{
1315 decltype(_impl_.stats_){from._impl_.stats_}
1316 , decltype(_impl_.metadata_id_){}
1317 , decltype(_impl_.duration_ps_){}
1318 , decltype(_impl_.data_){}
1319 , /*decltype(_impl_._cached_size_)*/{}
1320 , /*decltype(_impl_._oneof_case_)*/{}};
1321
1322 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1323 ::memcpy(&_impl_.metadata_id_, &from._impl_.metadata_id_,
1324 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.duration_ps_) -
1325 reinterpret_cast<char*>(&_impl_.metadata_id_)) + sizeof(_impl_.duration_ps_));
1326 clear_has_data();
1327 switch (from.data_case()) {
1328 case kOffsetPs: {
1329 _this->_internal_set_offset_ps(from._internal_offset_ps());
1330 break;
1331 }
1332 case kNumOccurrences: {
1333 _this->_internal_set_num_occurrences(from._internal_num_occurrences());
1334 break;
1335 }
1336 case DATA_NOT_SET: {
1337 break;
1338 }
1339 }
1340 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XEvent)
1341 }
1342
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1343 inline void XEvent::SharedCtor(
1344 ::_pb::Arena* arena, bool is_message_owned) {
1345 (void)arena;
1346 (void)is_message_owned;
1347 new (&_impl_) Impl_{
1348 decltype(_impl_.stats_){arena}
1349 , decltype(_impl_.metadata_id_){::int64_t{0}}
1350 , decltype(_impl_.duration_ps_){::int64_t{0}}
1351 , decltype(_impl_.data_){}
1352 , /*decltype(_impl_._cached_size_)*/{}
1353 , /*decltype(_impl_._oneof_case_)*/{}
1354 };
1355 clear_has_data();
1356 }
1357
~XEvent()1358 XEvent::~XEvent() {
1359 // @@protoc_insertion_point(destructor:tensorflow.profiler.XEvent)
1360 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1361 (void)arena;
1362 return;
1363 }
1364 SharedDtor();
1365 }
1366
SharedDtor()1367 inline void XEvent::SharedDtor() {
1368 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1369 _impl_.stats_.~RepeatedPtrField();
1370 if (has_data()) {
1371 clear_data();
1372 }
1373 }
1374
SetCachedSize(int size) const1375 void XEvent::SetCachedSize(int size) const {
1376 _impl_._cached_size_.Set(size);
1377 }
1378
clear_data()1379 void XEvent::clear_data() {
1380 // @@protoc_insertion_point(one_of_clear_start:tensorflow.profiler.XEvent)
1381 switch (data_case()) {
1382 case kOffsetPs: {
1383 // No need to clear
1384 break;
1385 }
1386 case kNumOccurrences: {
1387 // No need to clear
1388 break;
1389 }
1390 case DATA_NOT_SET: {
1391 break;
1392 }
1393 }
1394 _impl_._oneof_case_[0] = DATA_NOT_SET;
1395 }
1396
1397
Clear()1398 void XEvent::Clear() {
1399 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XEvent)
1400 ::uint32_t cached_has_bits = 0;
1401 // Prevent compiler warnings about cached_has_bits being unused
1402 (void) cached_has_bits;
1403
1404 _impl_.stats_.Clear();
1405 ::memset(&_impl_.metadata_id_, 0, static_cast<size_t>(
1406 reinterpret_cast<char*>(&_impl_.duration_ps_) -
1407 reinterpret_cast<char*>(&_impl_.metadata_id_)) + sizeof(_impl_.duration_ps_));
1408 clear_data();
1409 _internal_metadata_.Clear<std::string>();
1410 }
1411
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1412 const char* XEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1413 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1414 while (!ctx->Done(&ptr)) {
1415 ::uint32_t tag;
1416 ptr = ::_pbi::ReadTag(ptr, &tag);
1417 switch (tag >> 3) {
1418 // int64 metadata_id = 1;
1419 case 1:
1420 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1421 _impl_.metadata_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1422 CHK_(ptr);
1423 } else {
1424 goto handle_unusual;
1425 }
1426 continue;
1427 // int64 offset_ps = 2;
1428 case 2:
1429 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1430 _internal_set_offset_ps(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1431 CHK_(ptr);
1432 } else {
1433 goto handle_unusual;
1434 }
1435 continue;
1436 // int64 duration_ps = 3;
1437 case 3:
1438 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1439 _impl_.duration_ps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1440 CHK_(ptr);
1441 } else {
1442 goto handle_unusual;
1443 }
1444 continue;
1445 // repeated .tensorflow.profiler.XStat stats = 4;
1446 case 4:
1447 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1448 ptr -= 1;
1449 do {
1450 ptr += 1;
1451 ptr = ctx->ParseMessage(_internal_add_stats(), ptr);
1452 CHK_(ptr);
1453 if (!ctx->DataAvailable(ptr)) break;
1454 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
1455 } else {
1456 goto handle_unusual;
1457 }
1458 continue;
1459 // int64 num_occurrences = 5;
1460 case 5:
1461 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1462 _internal_set_num_occurrences(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1463 CHK_(ptr);
1464 } else {
1465 goto handle_unusual;
1466 }
1467 continue;
1468 default:
1469 goto handle_unusual;
1470 } // switch
1471 handle_unusual:
1472 if ((tag == 0) || ((tag & 7) == 4)) {
1473 CHK_(ptr);
1474 ctx->SetLastTag(tag);
1475 goto message_done;
1476 }
1477 ptr = UnknownFieldParse(
1478 tag,
1479 _internal_metadata_.mutable_unknown_fields<std::string>(),
1480 ptr, ctx);
1481 CHK_(ptr != nullptr);
1482 } // while
1483 message_done:
1484 return ptr;
1485 failure:
1486 ptr = nullptr;
1487 goto message_done;
1488 #undef CHK_
1489 }
1490
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1491 ::uint8_t* XEvent::_InternalSerialize(
1492 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1493 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XEvent)
1494 ::uint32_t cached_has_bits = 0;
1495 (void) cached_has_bits;
1496
1497 // int64 metadata_id = 1;
1498 if (this->_internal_metadata_id() != 0) {
1499 target = stream->EnsureSpace(target);
1500 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_metadata_id(), target);
1501 }
1502
1503 // int64 offset_ps = 2;
1504 if (_internal_has_offset_ps()) {
1505 target = stream->EnsureSpace(target);
1506 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_offset_ps(), target);
1507 }
1508
1509 // int64 duration_ps = 3;
1510 if (this->_internal_duration_ps() != 0) {
1511 target = stream->EnsureSpace(target);
1512 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_duration_ps(), target);
1513 }
1514
1515 // repeated .tensorflow.profiler.XStat stats = 4;
1516 for (unsigned i = 0,
1517 n = static_cast<unsigned>(this->_internal_stats_size()); i < n; i++) {
1518 const auto& repfield = this->_internal_stats(i);
1519 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1520 InternalWriteMessage(4, repfield, repfield.GetCachedSize(), target, stream);
1521 }
1522
1523 // int64 num_occurrences = 5;
1524 if (_internal_has_num_occurrences()) {
1525 target = stream->EnsureSpace(target);
1526 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_num_occurrences(), target);
1527 }
1528
1529 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1530 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1531 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1532 }
1533 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XEvent)
1534 return target;
1535 }
1536
ByteSizeLong() const1537 size_t XEvent::ByteSizeLong() const {
1538 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XEvent)
1539 size_t total_size = 0;
1540
1541 ::uint32_t cached_has_bits = 0;
1542 // Prevent compiler warnings about cached_has_bits being unused
1543 (void) cached_has_bits;
1544
1545 // repeated .tensorflow.profiler.XStat stats = 4;
1546 total_size += 1UL * this->_internal_stats_size();
1547 for (const auto& msg : this->_impl_.stats_) {
1548 total_size +=
1549 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1550 }
1551
1552 // int64 metadata_id = 1;
1553 if (this->_internal_metadata_id() != 0) {
1554 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_metadata_id());
1555 }
1556
1557 // int64 duration_ps = 3;
1558 if (this->_internal_duration_ps() != 0) {
1559 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_duration_ps());
1560 }
1561
1562 switch (data_case()) {
1563 // int64 offset_ps = 2;
1564 case kOffsetPs: {
1565 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_offset_ps());
1566 break;
1567 }
1568 // int64 num_occurrences = 5;
1569 case kNumOccurrences: {
1570 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_num_occurrences());
1571 break;
1572 }
1573 case DATA_NOT_SET: {
1574 break;
1575 }
1576 }
1577 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1578 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1579 }
1580 int cached_size = ::_pbi::ToCachedSize(total_size);
1581 SetCachedSize(cached_size);
1582 return total_size;
1583 }
1584
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1585 void XEvent::CheckTypeAndMergeFrom(
1586 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1587 MergeFrom(*::_pbi::DownCast<const XEvent*>(
1588 &from));
1589 }
1590
MergeFrom(const XEvent & from)1591 void XEvent::MergeFrom(const XEvent& from) {
1592 XEvent* const _this = this;
1593 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XEvent)
1594 GOOGLE_DCHECK_NE(&from, _this);
1595 ::uint32_t cached_has_bits = 0;
1596 (void) cached_has_bits;
1597
1598 _this->_impl_.stats_.MergeFrom(from._impl_.stats_);
1599 if (from._internal_metadata_id() != 0) {
1600 _this->_internal_set_metadata_id(from._internal_metadata_id());
1601 }
1602 if (from._internal_duration_ps() != 0) {
1603 _this->_internal_set_duration_ps(from._internal_duration_ps());
1604 }
1605 switch (from.data_case()) {
1606 case kOffsetPs: {
1607 _this->_internal_set_offset_ps(from._internal_offset_ps());
1608 break;
1609 }
1610 case kNumOccurrences: {
1611 _this->_internal_set_num_occurrences(from._internal_num_occurrences());
1612 break;
1613 }
1614 case DATA_NOT_SET: {
1615 break;
1616 }
1617 }
1618 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1619 }
1620
CopyFrom(const XEvent & from)1621 void XEvent::CopyFrom(const XEvent& from) {
1622 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XEvent)
1623 if (&from == this) return;
1624 Clear();
1625 MergeFrom(from);
1626 }
1627
IsInitialized() const1628 bool XEvent::IsInitialized() const {
1629 return true;
1630 }
1631
InternalSwap(XEvent * other)1632 void XEvent::InternalSwap(XEvent* other) {
1633 using std::swap;
1634 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1635 _impl_.stats_.InternalSwap(&other->_impl_.stats_);
1636 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1637 PROTOBUF_FIELD_OFFSET(XEvent, _impl_.duration_ps_)
1638 + sizeof(XEvent::_impl_.duration_ps_) // NOLINT
1639 - PROTOBUF_FIELD_OFFSET(XEvent, _impl_.metadata_id_)>(
1640 reinterpret_cast<char*>(&_impl_.metadata_id_),
1641 reinterpret_cast<char*>(&other->_impl_.metadata_id_));
1642 swap(_impl_.data_, other->_impl_.data_);
1643 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
1644 }
1645
GetTypeName() const1646 std::string XEvent::GetTypeName() const {
1647 return "tensorflow.profiler.XEvent";
1648 }
1649
1650
1651 // ===================================================================
1652
1653 class XStat::_Internal {
1654 public:
1655 };
1656
XStat(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1657 XStat::XStat(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1658 bool is_message_owned)
1659 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1660 SharedCtor(arena, is_message_owned);
1661 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XStat)
1662 }
XStat(const XStat & from)1663 XStat::XStat(const XStat& from)
1664 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1665 XStat* const _this = this; (void)_this;
1666 new (&_impl_) Impl_{
1667 decltype(_impl_.metadata_id_){}
1668 , decltype(_impl_.value_){}
1669 , /*decltype(_impl_._cached_size_)*/{}
1670 , /*decltype(_impl_._oneof_case_)*/{}};
1671
1672 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1673 _this->_impl_.metadata_id_ = from._impl_.metadata_id_;
1674 clear_has_value();
1675 switch (from.value_case()) {
1676 case kDoubleValue: {
1677 _this->_internal_set_double_value(from._internal_double_value());
1678 break;
1679 }
1680 case kUint64Value: {
1681 _this->_internal_set_uint64_value(from._internal_uint64_value());
1682 break;
1683 }
1684 case kInt64Value: {
1685 _this->_internal_set_int64_value(from._internal_int64_value());
1686 break;
1687 }
1688 case kStrValue: {
1689 _this->_internal_set_str_value(from._internal_str_value());
1690 break;
1691 }
1692 case kBytesValue: {
1693 _this->_internal_set_bytes_value(from._internal_bytes_value());
1694 break;
1695 }
1696 case kRefValue: {
1697 _this->_internal_set_ref_value(from._internal_ref_value());
1698 break;
1699 }
1700 case VALUE_NOT_SET: {
1701 break;
1702 }
1703 }
1704 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XStat)
1705 }
1706
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1707 inline void XStat::SharedCtor(
1708 ::_pb::Arena* arena, bool is_message_owned) {
1709 (void)arena;
1710 (void)is_message_owned;
1711 new (&_impl_) Impl_{
1712 decltype(_impl_.metadata_id_){::int64_t{0}}
1713 , decltype(_impl_.value_){}
1714 , /*decltype(_impl_._cached_size_)*/{}
1715 , /*decltype(_impl_._oneof_case_)*/{}
1716 };
1717 clear_has_value();
1718 }
1719
~XStat()1720 XStat::~XStat() {
1721 // @@protoc_insertion_point(destructor:tensorflow.profiler.XStat)
1722 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1723 (void)arena;
1724 return;
1725 }
1726 SharedDtor();
1727 }
1728
SharedDtor()1729 inline void XStat::SharedDtor() {
1730 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1731 if (has_value()) {
1732 clear_value();
1733 }
1734 }
1735
SetCachedSize(int size) const1736 void XStat::SetCachedSize(int size) const {
1737 _impl_._cached_size_.Set(size);
1738 }
1739
clear_value()1740 void XStat::clear_value() {
1741 // @@protoc_insertion_point(one_of_clear_start:tensorflow.profiler.XStat)
1742 switch (value_case()) {
1743 case kDoubleValue: {
1744 // No need to clear
1745 break;
1746 }
1747 case kUint64Value: {
1748 // No need to clear
1749 break;
1750 }
1751 case kInt64Value: {
1752 // No need to clear
1753 break;
1754 }
1755 case kStrValue: {
1756 _impl_.value_.str_value_.Destroy();
1757 break;
1758 }
1759 case kBytesValue: {
1760 _impl_.value_.bytes_value_.Destroy();
1761 break;
1762 }
1763 case kRefValue: {
1764 // No need to clear
1765 break;
1766 }
1767 case VALUE_NOT_SET: {
1768 break;
1769 }
1770 }
1771 _impl_._oneof_case_[0] = VALUE_NOT_SET;
1772 }
1773
1774
Clear()1775 void XStat::Clear() {
1776 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XStat)
1777 ::uint32_t cached_has_bits = 0;
1778 // Prevent compiler warnings about cached_has_bits being unused
1779 (void) cached_has_bits;
1780
1781 _impl_.metadata_id_ = ::int64_t{0};
1782 clear_value();
1783 _internal_metadata_.Clear<std::string>();
1784 }
1785
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1786 const char* XStat::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1787 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1788 while (!ctx->Done(&ptr)) {
1789 ::uint32_t tag;
1790 ptr = ::_pbi::ReadTag(ptr, &tag);
1791 switch (tag >> 3) {
1792 // int64 metadata_id = 1;
1793 case 1:
1794 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1795 _impl_.metadata_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1796 CHK_(ptr);
1797 } else {
1798 goto handle_unusual;
1799 }
1800 continue;
1801 // double double_value = 2;
1802 case 2:
1803 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 17)) {
1804 _internal_set_double_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr));
1805 ptr += sizeof(double);
1806 } else {
1807 goto handle_unusual;
1808 }
1809 continue;
1810 // uint64 uint64_value = 3;
1811 case 3:
1812 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1813 _internal_set_uint64_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1814 CHK_(ptr);
1815 } else {
1816 goto handle_unusual;
1817 }
1818 continue;
1819 // int64 int64_value = 4;
1820 case 4:
1821 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1822 _internal_set_int64_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1823 CHK_(ptr);
1824 } else {
1825 goto handle_unusual;
1826 }
1827 continue;
1828 // string str_value = 5;
1829 case 5:
1830 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1831 auto str = _internal_mutable_str_value();
1832 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1833 CHK_(ptr);
1834 CHK_(::_pbi::VerifyUTF8(str, nullptr));
1835 } else {
1836 goto handle_unusual;
1837 }
1838 continue;
1839 // bytes bytes_value = 6;
1840 case 6:
1841 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1842 auto str = _internal_mutable_bytes_value();
1843 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1844 CHK_(ptr);
1845 } else {
1846 goto handle_unusual;
1847 }
1848 continue;
1849 // uint64 ref_value = 7;
1850 case 7:
1851 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1852 _internal_set_ref_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
1853 CHK_(ptr);
1854 } else {
1855 goto handle_unusual;
1856 }
1857 continue;
1858 default:
1859 goto handle_unusual;
1860 } // switch
1861 handle_unusual:
1862 if ((tag == 0) || ((tag & 7) == 4)) {
1863 CHK_(ptr);
1864 ctx->SetLastTag(tag);
1865 goto message_done;
1866 }
1867 ptr = UnknownFieldParse(
1868 tag,
1869 _internal_metadata_.mutable_unknown_fields<std::string>(),
1870 ptr, ctx);
1871 CHK_(ptr != nullptr);
1872 } // while
1873 message_done:
1874 return ptr;
1875 failure:
1876 ptr = nullptr;
1877 goto message_done;
1878 #undef CHK_
1879 }
1880
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1881 ::uint8_t* XStat::_InternalSerialize(
1882 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1883 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XStat)
1884 ::uint32_t cached_has_bits = 0;
1885 (void) cached_has_bits;
1886
1887 // int64 metadata_id = 1;
1888 if (this->_internal_metadata_id() != 0) {
1889 target = stream->EnsureSpace(target);
1890 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_metadata_id(), target);
1891 }
1892
1893 // double double_value = 2;
1894 if (_internal_has_double_value()) {
1895 target = stream->EnsureSpace(target);
1896 target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_double_value(), target);
1897 }
1898
1899 // uint64 uint64_value = 3;
1900 if (_internal_has_uint64_value()) {
1901 target = stream->EnsureSpace(target);
1902 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_uint64_value(), target);
1903 }
1904
1905 // int64 int64_value = 4;
1906 if (_internal_has_int64_value()) {
1907 target = stream->EnsureSpace(target);
1908 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_int64_value(), target);
1909 }
1910
1911 // string str_value = 5;
1912 if (_internal_has_str_value()) {
1913 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
1914 this->_internal_str_value().data(), static_cast<int>(this->_internal_str_value().length()),
1915 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
1916 "tensorflow.profiler.XStat.str_value");
1917 target = stream->WriteStringMaybeAliased(
1918 5, this->_internal_str_value(), target);
1919 }
1920
1921 // bytes bytes_value = 6;
1922 if (_internal_has_bytes_value()) {
1923 target = stream->WriteBytesMaybeAliased(
1924 6, this->_internal_bytes_value(), target);
1925 }
1926
1927 // uint64 ref_value = 7;
1928 if (_internal_has_ref_value()) {
1929 target = stream->EnsureSpace(target);
1930 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_ref_value(), target);
1931 }
1932
1933 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1934 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1935 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1936 }
1937 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XStat)
1938 return target;
1939 }
1940
ByteSizeLong() const1941 size_t XStat::ByteSizeLong() const {
1942 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XStat)
1943 size_t total_size = 0;
1944
1945 ::uint32_t cached_has_bits = 0;
1946 // Prevent compiler warnings about cached_has_bits being unused
1947 (void) cached_has_bits;
1948
1949 // int64 metadata_id = 1;
1950 if (this->_internal_metadata_id() != 0) {
1951 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_metadata_id());
1952 }
1953
1954 switch (value_case()) {
1955 // double double_value = 2;
1956 case kDoubleValue: {
1957 total_size += 1 + 8;
1958 break;
1959 }
1960 // uint64 uint64_value = 3;
1961 case kUint64Value: {
1962 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_uint64_value());
1963 break;
1964 }
1965 // int64 int64_value = 4;
1966 case kInt64Value: {
1967 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_int64_value());
1968 break;
1969 }
1970 // string str_value = 5;
1971 case kStrValue: {
1972 total_size += 1 +
1973 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1974 this->_internal_str_value());
1975 break;
1976 }
1977 // bytes bytes_value = 6;
1978 case kBytesValue: {
1979 total_size += 1 +
1980 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
1981 this->_internal_bytes_value());
1982 break;
1983 }
1984 // uint64 ref_value = 7;
1985 case kRefValue: {
1986 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ref_value());
1987 break;
1988 }
1989 case VALUE_NOT_SET: {
1990 break;
1991 }
1992 }
1993 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1994 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1995 }
1996 int cached_size = ::_pbi::ToCachedSize(total_size);
1997 SetCachedSize(cached_size);
1998 return total_size;
1999 }
2000
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2001 void XStat::CheckTypeAndMergeFrom(
2002 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2003 MergeFrom(*::_pbi::DownCast<const XStat*>(
2004 &from));
2005 }
2006
MergeFrom(const XStat & from)2007 void XStat::MergeFrom(const XStat& from) {
2008 XStat* const _this = this;
2009 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XStat)
2010 GOOGLE_DCHECK_NE(&from, _this);
2011 ::uint32_t cached_has_bits = 0;
2012 (void) cached_has_bits;
2013
2014 if (from._internal_metadata_id() != 0) {
2015 _this->_internal_set_metadata_id(from._internal_metadata_id());
2016 }
2017 switch (from.value_case()) {
2018 case kDoubleValue: {
2019 _this->_internal_set_double_value(from._internal_double_value());
2020 break;
2021 }
2022 case kUint64Value: {
2023 _this->_internal_set_uint64_value(from._internal_uint64_value());
2024 break;
2025 }
2026 case kInt64Value: {
2027 _this->_internal_set_int64_value(from._internal_int64_value());
2028 break;
2029 }
2030 case kStrValue: {
2031 _this->_internal_set_str_value(from._internal_str_value());
2032 break;
2033 }
2034 case kBytesValue: {
2035 _this->_internal_set_bytes_value(from._internal_bytes_value());
2036 break;
2037 }
2038 case kRefValue: {
2039 _this->_internal_set_ref_value(from._internal_ref_value());
2040 break;
2041 }
2042 case VALUE_NOT_SET: {
2043 break;
2044 }
2045 }
2046 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2047 }
2048
CopyFrom(const XStat & from)2049 void XStat::CopyFrom(const XStat& from) {
2050 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XStat)
2051 if (&from == this) return;
2052 Clear();
2053 MergeFrom(from);
2054 }
2055
IsInitialized() const2056 bool XStat::IsInitialized() const {
2057 return true;
2058 }
2059
InternalSwap(XStat * other)2060 void XStat::InternalSwap(XStat* other) {
2061 using std::swap;
2062 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2063 swap(_impl_.metadata_id_, other->_impl_.metadata_id_);
2064 swap(_impl_.value_, other->_impl_.value_);
2065 swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
2066 }
2067
GetTypeName() const2068 std::string XStat::GetTypeName() const {
2069 return "tensorflow.profiler.XStat";
2070 }
2071
2072
2073 // ===================================================================
2074
2075 class XEventMetadata::_Internal {
2076 public:
2077 };
2078
XEventMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2079 XEventMetadata::XEventMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2080 bool is_message_owned)
2081 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2082 SharedCtor(arena, is_message_owned);
2083 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XEventMetadata)
2084 }
XEventMetadata(const XEventMetadata & from)2085 XEventMetadata::XEventMetadata(const XEventMetadata& from)
2086 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2087 XEventMetadata* const _this = this; (void)_this;
2088 new (&_impl_) Impl_{
2089 decltype(_impl_.stats_){from._impl_.stats_}
2090 , decltype(_impl_.child_id_){from._impl_.child_id_}
2091 , /*decltype(_impl_._child_id_cached_byte_size_)*/{0}
2092 , decltype(_impl_.name_){}
2093 , decltype(_impl_.metadata_){}
2094 , decltype(_impl_.display_name_){}
2095 , decltype(_impl_.id_){}
2096 , /*decltype(_impl_._cached_size_)*/{}};
2097
2098 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2099 _impl_.name_.InitDefault();
2100 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2101 _impl_.name_.Set("", GetArenaForAllocation());
2102 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2103 if (!from._internal_name().empty()) {
2104 _this->_impl_.name_.Set(from._internal_name(),
2105 _this->GetArenaForAllocation());
2106 }
2107 _impl_.metadata_.InitDefault();
2108 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2109 _impl_.metadata_.Set("", GetArenaForAllocation());
2110 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2111 if (!from._internal_metadata().empty()) {
2112 _this->_impl_.metadata_.Set(from._internal_metadata(),
2113 _this->GetArenaForAllocation());
2114 }
2115 _impl_.display_name_.InitDefault();
2116 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2117 _impl_.display_name_.Set("", GetArenaForAllocation());
2118 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2119 if (!from._internal_display_name().empty()) {
2120 _this->_impl_.display_name_.Set(from._internal_display_name(),
2121 _this->GetArenaForAllocation());
2122 }
2123 _this->_impl_.id_ = from._impl_.id_;
2124 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XEventMetadata)
2125 }
2126
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2127 inline void XEventMetadata::SharedCtor(
2128 ::_pb::Arena* arena, bool is_message_owned) {
2129 (void)arena;
2130 (void)is_message_owned;
2131 new (&_impl_) Impl_{
2132 decltype(_impl_.stats_){arena}
2133 , decltype(_impl_.child_id_){arena}
2134 , /*decltype(_impl_._child_id_cached_byte_size_)*/{0}
2135 , decltype(_impl_.name_){}
2136 , decltype(_impl_.metadata_){}
2137 , decltype(_impl_.display_name_){}
2138 , decltype(_impl_.id_){::int64_t{0}}
2139 , /*decltype(_impl_._cached_size_)*/{}
2140 };
2141 _impl_.name_.InitDefault();
2142 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2143 _impl_.name_.Set("", GetArenaForAllocation());
2144 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2145 _impl_.metadata_.InitDefault();
2146 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2147 _impl_.metadata_.Set("", GetArenaForAllocation());
2148 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2149 _impl_.display_name_.InitDefault();
2150 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2151 _impl_.display_name_.Set("", GetArenaForAllocation());
2152 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2153 }
2154
~XEventMetadata()2155 XEventMetadata::~XEventMetadata() {
2156 // @@protoc_insertion_point(destructor:tensorflow.profiler.XEventMetadata)
2157 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2158 (void)arena;
2159 return;
2160 }
2161 SharedDtor();
2162 }
2163
SharedDtor()2164 inline void XEventMetadata::SharedDtor() {
2165 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2166 _impl_.stats_.~RepeatedPtrField();
2167 _impl_.child_id_.~RepeatedField();
2168 _impl_.name_.Destroy();
2169 _impl_.metadata_.Destroy();
2170 _impl_.display_name_.Destroy();
2171 }
2172
SetCachedSize(int size) const2173 void XEventMetadata::SetCachedSize(int size) const {
2174 _impl_._cached_size_.Set(size);
2175 }
2176
Clear()2177 void XEventMetadata::Clear() {
2178 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XEventMetadata)
2179 ::uint32_t cached_has_bits = 0;
2180 // Prevent compiler warnings about cached_has_bits being unused
2181 (void) cached_has_bits;
2182
2183 _impl_.stats_.Clear();
2184 _impl_.child_id_.Clear();
2185 _impl_.name_.ClearToEmpty();
2186 _impl_.metadata_.ClearToEmpty();
2187 _impl_.display_name_.ClearToEmpty();
2188 _impl_.id_ = ::int64_t{0};
2189 _internal_metadata_.Clear<std::string>();
2190 }
2191
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2192 const char* XEventMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2193 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2194 while (!ctx->Done(&ptr)) {
2195 ::uint32_t tag;
2196 ptr = ::_pbi::ReadTag(ptr, &tag);
2197 switch (tag >> 3) {
2198 // int64 id = 1;
2199 case 1:
2200 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2201 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2202 CHK_(ptr);
2203 } else {
2204 goto handle_unusual;
2205 }
2206 continue;
2207 // string name = 2;
2208 case 2:
2209 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2210 auto str = _internal_mutable_name();
2211 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2212 CHK_(ptr);
2213 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2214 } else {
2215 goto handle_unusual;
2216 }
2217 continue;
2218 // bytes metadata = 3;
2219 case 3:
2220 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2221 auto str = _internal_mutable_metadata();
2222 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2223 CHK_(ptr);
2224 } else {
2225 goto handle_unusual;
2226 }
2227 continue;
2228 // string display_name = 4;
2229 case 4:
2230 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
2231 auto str = _internal_mutable_display_name();
2232 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2233 CHK_(ptr);
2234 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2235 } else {
2236 goto handle_unusual;
2237 }
2238 continue;
2239 // repeated .tensorflow.profiler.XStat stats = 5;
2240 case 5:
2241 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2242 ptr -= 1;
2243 do {
2244 ptr += 1;
2245 ptr = ctx->ParseMessage(_internal_add_stats(), ptr);
2246 CHK_(ptr);
2247 if (!ctx->DataAvailable(ptr)) break;
2248 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
2249 } else {
2250 goto handle_unusual;
2251 }
2252 continue;
2253 // repeated int64 child_id = 6;
2254 case 6:
2255 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
2256 ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_child_id(), ptr, ctx);
2257 CHK_(ptr);
2258 } else if (static_cast<::uint8_t>(tag) == 48) {
2259 _internal_add_child_id(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
2260 CHK_(ptr);
2261 } else {
2262 goto handle_unusual;
2263 }
2264 continue;
2265 default:
2266 goto handle_unusual;
2267 } // switch
2268 handle_unusual:
2269 if ((tag == 0) || ((tag & 7) == 4)) {
2270 CHK_(ptr);
2271 ctx->SetLastTag(tag);
2272 goto message_done;
2273 }
2274 ptr = UnknownFieldParse(
2275 tag,
2276 _internal_metadata_.mutable_unknown_fields<std::string>(),
2277 ptr, ctx);
2278 CHK_(ptr != nullptr);
2279 } // while
2280 message_done:
2281 return ptr;
2282 failure:
2283 ptr = nullptr;
2284 goto message_done;
2285 #undef CHK_
2286 }
2287
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2288 ::uint8_t* XEventMetadata::_InternalSerialize(
2289 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2290 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XEventMetadata)
2291 ::uint32_t cached_has_bits = 0;
2292 (void) cached_has_bits;
2293
2294 // int64 id = 1;
2295 if (this->_internal_id() != 0) {
2296 target = stream->EnsureSpace(target);
2297 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_id(), target);
2298 }
2299
2300 // string name = 2;
2301 if (!this->_internal_name().empty()) {
2302 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2303 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
2304 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2305 "tensorflow.profiler.XEventMetadata.name");
2306 target = stream->WriteStringMaybeAliased(
2307 2, this->_internal_name(), target);
2308 }
2309
2310 // bytes metadata = 3;
2311 if (!this->_internal_metadata().empty()) {
2312 target = stream->WriteBytesMaybeAliased(
2313 3, this->_internal_metadata(), target);
2314 }
2315
2316 // string display_name = 4;
2317 if (!this->_internal_display_name().empty()) {
2318 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2319 this->_internal_display_name().data(), static_cast<int>(this->_internal_display_name().length()),
2320 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2321 "tensorflow.profiler.XEventMetadata.display_name");
2322 target = stream->WriteStringMaybeAliased(
2323 4, this->_internal_display_name(), target);
2324 }
2325
2326 // repeated .tensorflow.profiler.XStat stats = 5;
2327 for (unsigned i = 0,
2328 n = static_cast<unsigned>(this->_internal_stats_size()); i < n; i++) {
2329 const auto& repfield = this->_internal_stats(i);
2330 target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
2331 InternalWriteMessage(5, repfield, repfield.GetCachedSize(), target, stream);
2332 }
2333
2334 // repeated int64 child_id = 6;
2335 {
2336 int byte_size = _impl_._child_id_cached_byte_size_.load(std::memory_order_relaxed);
2337 if (byte_size > 0) {
2338 target = stream->WriteInt64Packed(
2339 6, _internal_child_id(), byte_size, target);
2340 }
2341 }
2342
2343 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2344 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2345 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2346 }
2347 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XEventMetadata)
2348 return target;
2349 }
2350
ByteSizeLong() const2351 size_t XEventMetadata::ByteSizeLong() const {
2352 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XEventMetadata)
2353 size_t total_size = 0;
2354
2355 ::uint32_t cached_has_bits = 0;
2356 // Prevent compiler warnings about cached_has_bits being unused
2357 (void) cached_has_bits;
2358
2359 // repeated .tensorflow.profiler.XStat stats = 5;
2360 total_size += 1UL * this->_internal_stats_size();
2361 for (const auto& msg : this->_impl_.stats_) {
2362 total_size +=
2363 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
2364 }
2365
2366 // repeated int64 child_id = 6;
2367 {
2368 size_t data_size = ::_pbi::WireFormatLite::
2369 Int64Size(this->_impl_.child_id_);
2370 if (data_size > 0) {
2371 total_size += 1 +
2372 ::_pbi::WireFormatLite::Int32Size(static_cast<::int32_t>(data_size));
2373 }
2374 int cached_size = ::_pbi::ToCachedSize(data_size);
2375 _impl_._child_id_cached_byte_size_.store(cached_size,
2376 std::memory_order_relaxed);
2377 total_size += data_size;
2378 }
2379
2380 // string name = 2;
2381 if (!this->_internal_name().empty()) {
2382 total_size += 1 +
2383 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2384 this->_internal_name());
2385 }
2386
2387 // bytes metadata = 3;
2388 if (!this->_internal_metadata().empty()) {
2389 total_size += 1 +
2390 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
2391 this->_internal_metadata());
2392 }
2393
2394 // string display_name = 4;
2395 if (!this->_internal_display_name().empty()) {
2396 total_size += 1 +
2397 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2398 this->_internal_display_name());
2399 }
2400
2401 // int64 id = 1;
2402 if (this->_internal_id() != 0) {
2403 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_id());
2404 }
2405
2406 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2407 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2408 }
2409 int cached_size = ::_pbi::ToCachedSize(total_size);
2410 SetCachedSize(cached_size);
2411 return total_size;
2412 }
2413
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2414 void XEventMetadata::CheckTypeAndMergeFrom(
2415 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2416 MergeFrom(*::_pbi::DownCast<const XEventMetadata*>(
2417 &from));
2418 }
2419
MergeFrom(const XEventMetadata & from)2420 void XEventMetadata::MergeFrom(const XEventMetadata& from) {
2421 XEventMetadata* const _this = this;
2422 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XEventMetadata)
2423 GOOGLE_DCHECK_NE(&from, _this);
2424 ::uint32_t cached_has_bits = 0;
2425 (void) cached_has_bits;
2426
2427 _this->_impl_.stats_.MergeFrom(from._impl_.stats_);
2428 _this->_impl_.child_id_.MergeFrom(from._impl_.child_id_);
2429 if (!from._internal_name().empty()) {
2430 _this->_internal_set_name(from._internal_name());
2431 }
2432 if (!from._internal_metadata().empty()) {
2433 _this->_internal_set_metadata(from._internal_metadata());
2434 }
2435 if (!from._internal_display_name().empty()) {
2436 _this->_internal_set_display_name(from._internal_display_name());
2437 }
2438 if (from._internal_id() != 0) {
2439 _this->_internal_set_id(from._internal_id());
2440 }
2441 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2442 }
2443
CopyFrom(const XEventMetadata & from)2444 void XEventMetadata::CopyFrom(const XEventMetadata& from) {
2445 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XEventMetadata)
2446 if (&from == this) return;
2447 Clear();
2448 MergeFrom(from);
2449 }
2450
IsInitialized() const2451 bool XEventMetadata::IsInitialized() const {
2452 return true;
2453 }
2454
InternalSwap(XEventMetadata * other)2455 void XEventMetadata::InternalSwap(XEventMetadata* other) {
2456 using std::swap;
2457 auto* lhs_arena = GetArenaForAllocation();
2458 auto* rhs_arena = other->GetArenaForAllocation();
2459 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2460 _impl_.stats_.InternalSwap(&other->_impl_.stats_);
2461 _impl_.child_id_.InternalSwap(&other->_impl_.child_id_);
2462 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2463 &_impl_.name_, lhs_arena,
2464 &other->_impl_.name_, rhs_arena
2465 );
2466 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2467 &_impl_.metadata_, lhs_arena,
2468 &other->_impl_.metadata_, rhs_arena
2469 );
2470 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2471 &_impl_.display_name_, lhs_arena,
2472 &other->_impl_.display_name_, rhs_arena
2473 );
2474 swap(_impl_.id_, other->_impl_.id_);
2475 }
2476
GetTypeName() const2477 std::string XEventMetadata::GetTypeName() const {
2478 return "tensorflow.profiler.XEventMetadata";
2479 }
2480
2481
2482 // ===================================================================
2483
2484 class XStatMetadata::_Internal {
2485 public:
2486 };
2487
XStatMetadata(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2488 XStatMetadata::XStatMetadata(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2489 bool is_message_owned)
2490 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2491 SharedCtor(arena, is_message_owned);
2492 // @@protoc_insertion_point(arena_constructor:tensorflow.profiler.XStatMetadata)
2493 }
XStatMetadata(const XStatMetadata & from)2494 XStatMetadata::XStatMetadata(const XStatMetadata& from)
2495 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2496 XStatMetadata* const _this = this; (void)_this;
2497 new (&_impl_) Impl_{
2498 decltype(_impl_.name_){}
2499 , decltype(_impl_.description_){}
2500 , decltype(_impl_.id_){}
2501 , /*decltype(_impl_._cached_size_)*/{}};
2502
2503 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2504 _impl_.name_.InitDefault();
2505 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2506 _impl_.name_.Set("", GetArenaForAllocation());
2507 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2508 if (!from._internal_name().empty()) {
2509 _this->_impl_.name_.Set(from._internal_name(),
2510 _this->GetArenaForAllocation());
2511 }
2512 _impl_.description_.InitDefault();
2513 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2514 _impl_.description_.Set("", GetArenaForAllocation());
2515 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2516 if (!from._internal_description().empty()) {
2517 _this->_impl_.description_.Set(from._internal_description(),
2518 _this->GetArenaForAllocation());
2519 }
2520 _this->_impl_.id_ = from._impl_.id_;
2521 // @@protoc_insertion_point(copy_constructor:tensorflow.profiler.XStatMetadata)
2522 }
2523
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2524 inline void XStatMetadata::SharedCtor(
2525 ::_pb::Arena* arena, bool is_message_owned) {
2526 (void)arena;
2527 (void)is_message_owned;
2528 new (&_impl_) Impl_{
2529 decltype(_impl_.name_){}
2530 , decltype(_impl_.description_){}
2531 , decltype(_impl_.id_){::int64_t{0}}
2532 , /*decltype(_impl_._cached_size_)*/{}
2533 };
2534 _impl_.name_.InitDefault();
2535 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2536 _impl_.name_.Set("", GetArenaForAllocation());
2537 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2538 _impl_.description_.InitDefault();
2539 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2540 _impl_.description_.Set("", GetArenaForAllocation());
2541 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2542 }
2543
~XStatMetadata()2544 XStatMetadata::~XStatMetadata() {
2545 // @@protoc_insertion_point(destructor:tensorflow.profiler.XStatMetadata)
2546 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2547 (void)arena;
2548 return;
2549 }
2550 SharedDtor();
2551 }
2552
SharedDtor()2553 inline void XStatMetadata::SharedDtor() {
2554 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2555 _impl_.name_.Destroy();
2556 _impl_.description_.Destroy();
2557 }
2558
SetCachedSize(int size) const2559 void XStatMetadata::SetCachedSize(int size) const {
2560 _impl_._cached_size_.Set(size);
2561 }
2562
Clear()2563 void XStatMetadata::Clear() {
2564 // @@protoc_insertion_point(message_clear_start:tensorflow.profiler.XStatMetadata)
2565 ::uint32_t cached_has_bits = 0;
2566 // Prevent compiler warnings about cached_has_bits being unused
2567 (void) cached_has_bits;
2568
2569 _impl_.name_.ClearToEmpty();
2570 _impl_.description_.ClearToEmpty();
2571 _impl_.id_ = ::int64_t{0};
2572 _internal_metadata_.Clear<std::string>();
2573 }
2574
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2575 const char* XStatMetadata::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2576 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2577 while (!ctx->Done(&ptr)) {
2578 ::uint32_t tag;
2579 ptr = ::_pbi::ReadTag(ptr, &tag);
2580 switch (tag >> 3) {
2581 // int64 id = 1;
2582 case 1:
2583 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2584 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2585 CHK_(ptr);
2586 } else {
2587 goto handle_unusual;
2588 }
2589 continue;
2590 // string name = 2;
2591 case 2:
2592 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2593 auto str = _internal_mutable_name();
2594 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2595 CHK_(ptr);
2596 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2597 } else {
2598 goto handle_unusual;
2599 }
2600 continue;
2601 // string description = 3;
2602 case 3:
2603 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2604 auto str = _internal_mutable_description();
2605 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2606 CHK_(ptr);
2607 CHK_(::_pbi::VerifyUTF8(str, nullptr));
2608 } else {
2609 goto handle_unusual;
2610 }
2611 continue;
2612 default:
2613 goto handle_unusual;
2614 } // switch
2615 handle_unusual:
2616 if ((tag == 0) || ((tag & 7) == 4)) {
2617 CHK_(ptr);
2618 ctx->SetLastTag(tag);
2619 goto message_done;
2620 }
2621 ptr = UnknownFieldParse(
2622 tag,
2623 _internal_metadata_.mutable_unknown_fields<std::string>(),
2624 ptr, ctx);
2625 CHK_(ptr != nullptr);
2626 } // while
2627 message_done:
2628 return ptr;
2629 failure:
2630 ptr = nullptr;
2631 goto message_done;
2632 #undef CHK_
2633 }
2634
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2635 ::uint8_t* XStatMetadata::_InternalSerialize(
2636 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2637 // @@protoc_insertion_point(serialize_to_array_start:tensorflow.profiler.XStatMetadata)
2638 ::uint32_t cached_has_bits = 0;
2639 (void) cached_has_bits;
2640
2641 // int64 id = 1;
2642 if (this->_internal_id() != 0) {
2643 target = stream->EnsureSpace(target);
2644 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_id(), target);
2645 }
2646
2647 // string name = 2;
2648 if (!this->_internal_name().empty()) {
2649 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2650 this->_internal_name().data(), static_cast<int>(this->_internal_name().length()),
2651 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2652 "tensorflow.profiler.XStatMetadata.name");
2653 target = stream->WriteStringMaybeAliased(
2654 2, this->_internal_name(), target);
2655 }
2656
2657 // string description = 3;
2658 if (!this->_internal_description().empty()) {
2659 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
2660 this->_internal_description().data(), static_cast<int>(this->_internal_description().length()),
2661 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
2662 "tensorflow.profiler.XStatMetadata.description");
2663 target = stream->WriteStringMaybeAliased(
2664 3, this->_internal_description(), target);
2665 }
2666
2667 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2668 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2669 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2670 }
2671 // @@protoc_insertion_point(serialize_to_array_end:tensorflow.profiler.XStatMetadata)
2672 return target;
2673 }
2674
ByteSizeLong() const2675 size_t XStatMetadata::ByteSizeLong() const {
2676 // @@protoc_insertion_point(message_byte_size_start:tensorflow.profiler.XStatMetadata)
2677 size_t total_size = 0;
2678
2679 ::uint32_t cached_has_bits = 0;
2680 // Prevent compiler warnings about cached_has_bits being unused
2681 (void) cached_has_bits;
2682
2683 // string name = 2;
2684 if (!this->_internal_name().empty()) {
2685 total_size += 1 +
2686 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2687 this->_internal_name());
2688 }
2689
2690 // string description = 3;
2691 if (!this->_internal_description().empty()) {
2692 total_size += 1 +
2693 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2694 this->_internal_description());
2695 }
2696
2697 // int64 id = 1;
2698 if (this->_internal_id() != 0) {
2699 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_id());
2700 }
2701
2702 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2703 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2704 }
2705 int cached_size = ::_pbi::ToCachedSize(total_size);
2706 SetCachedSize(cached_size);
2707 return total_size;
2708 }
2709
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2710 void XStatMetadata::CheckTypeAndMergeFrom(
2711 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2712 MergeFrom(*::_pbi::DownCast<const XStatMetadata*>(
2713 &from));
2714 }
2715
MergeFrom(const XStatMetadata & from)2716 void XStatMetadata::MergeFrom(const XStatMetadata& from) {
2717 XStatMetadata* const _this = this;
2718 // @@protoc_insertion_point(class_specific_merge_from_start:tensorflow.profiler.XStatMetadata)
2719 GOOGLE_DCHECK_NE(&from, _this);
2720 ::uint32_t cached_has_bits = 0;
2721 (void) cached_has_bits;
2722
2723 if (!from._internal_name().empty()) {
2724 _this->_internal_set_name(from._internal_name());
2725 }
2726 if (!from._internal_description().empty()) {
2727 _this->_internal_set_description(from._internal_description());
2728 }
2729 if (from._internal_id() != 0) {
2730 _this->_internal_set_id(from._internal_id());
2731 }
2732 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2733 }
2734
CopyFrom(const XStatMetadata & from)2735 void XStatMetadata::CopyFrom(const XStatMetadata& from) {
2736 // @@protoc_insertion_point(class_specific_copy_from_start:tensorflow.profiler.XStatMetadata)
2737 if (&from == this) return;
2738 Clear();
2739 MergeFrom(from);
2740 }
2741
IsInitialized() const2742 bool XStatMetadata::IsInitialized() const {
2743 return true;
2744 }
2745
InternalSwap(XStatMetadata * other)2746 void XStatMetadata::InternalSwap(XStatMetadata* other) {
2747 using std::swap;
2748 auto* lhs_arena = GetArenaForAllocation();
2749 auto* rhs_arena = other->GetArenaForAllocation();
2750 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2751 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2752 &_impl_.name_, lhs_arena,
2753 &other->_impl_.name_, rhs_arena
2754 );
2755 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2756 &_impl_.description_, lhs_arena,
2757 &other->_impl_.description_, rhs_arena
2758 );
2759 swap(_impl_.id_, other->_impl_.id_);
2760 }
2761
GetTypeName() const2762 std::string XStatMetadata::GetTypeName() const {
2763 return "tensorflow.profiler.XStatMetadata";
2764 }
2765
2766
2767 // @@protoc_insertion_point(namespace_scope)
2768 } // namespace profiler
2769 } // namespace tensorflow
2770 PROTOBUF_NAMESPACE_OPEN
2771 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XSpace*
CreateMaybeMessage(Arena * arena)2772 Arena::CreateMaybeMessage< ::tensorflow::profiler::XSpace >(Arena* arena) {
2773 return Arena::CreateMessageInternal< ::tensorflow::profiler::XSpace >(arena);
2774 }
2775 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XPlane_EventMetadataEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)2776 Arena::CreateMaybeMessage< ::tensorflow::profiler::XPlane_EventMetadataEntry_DoNotUse >(Arena* arena) {
2777 return Arena::CreateMessageInternal< ::tensorflow::profiler::XPlane_EventMetadataEntry_DoNotUse >(arena);
2778 }
2779 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XPlane_StatMetadataEntry_DoNotUse*
CreateMaybeMessage(Arena * arena)2780 Arena::CreateMaybeMessage< ::tensorflow::profiler::XPlane_StatMetadataEntry_DoNotUse >(Arena* arena) {
2781 return Arena::CreateMessageInternal< ::tensorflow::profiler::XPlane_StatMetadataEntry_DoNotUse >(arena);
2782 }
2783 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XPlane*
CreateMaybeMessage(Arena * arena)2784 Arena::CreateMaybeMessage< ::tensorflow::profiler::XPlane >(Arena* arena) {
2785 return Arena::CreateMessageInternal< ::tensorflow::profiler::XPlane >(arena);
2786 }
2787 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XLine*
CreateMaybeMessage(Arena * arena)2788 Arena::CreateMaybeMessage< ::tensorflow::profiler::XLine >(Arena* arena) {
2789 return Arena::CreateMessageInternal< ::tensorflow::profiler::XLine >(arena);
2790 }
2791 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XEvent*
CreateMaybeMessage(Arena * arena)2792 Arena::CreateMaybeMessage< ::tensorflow::profiler::XEvent >(Arena* arena) {
2793 return Arena::CreateMessageInternal< ::tensorflow::profiler::XEvent >(arena);
2794 }
2795 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XStat*
CreateMaybeMessage(Arena * arena)2796 Arena::CreateMaybeMessage< ::tensorflow::profiler::XStat >(Arena* arena) {
2797 return Arena::CreateMessageInternal< ::tensorflow::profiler::XStat >(arena);
2798 }
2799 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XEventMetadata*
CreateMaybeMessage(Arena * arena)2800 Arena::CreateMaybeMessage< ::tensorflow::profiler::XEventMetadata >(Arena* arena) {
2801 return Arena::CreateMessageInternal< ::tensorflow::profiler::XEventMetadata >(arena);
2802 }
2803 template<> PROTOBUF_NOINLINE ::tensorflow::profiler::XStatMetadata*
CreateMaybeMessage(Arena * arena)2804 Arena::CreateMaybeMessage< ::tensorflow::profiler::XStatMetadata >(Arena* arena) {
2805 return Arena::CreateMessageInternal< ::tensorflow::profiler::XStatMetadata >(arena);
2806 }
2807 PROTOBUF_NAMESPACE_CLOSE
2808
2809 // @@protoc_insertion_point(global_scope)
2810 #include <google/protobuf/port_undef.inc>
2811