1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/synthetic.proto
3
4 #include "protos/perfetto/trace/ftrace/synthetic.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 perfetto {
22 namespace protos {
RssStatThrottledFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR RssStatThrottledFtraceEvent::RssStatThrottledFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.curr_)*/0u
28 , /*decltype(_impl_.member_)*/0
29 , /*decltype(_impl_.size_)*/::int64_t{0}
30 , /*decltype(_impl_.mm_id_)*/0u} {}
31 struct RssStatThrottledFtraceEventDefaultTypeInternal {
RssStatThrottledFtraceEventDefaultTypeInternalperfetto::protos::RssStatThrottledFtraceEventDefaultTypeInternal32 PROTOBUF_CONSTEXPR RssStatThrottledFtraceEventDefaultTypeInternal()
33 : _instance(::_pbi::ConstantInitialized{}) {}
~RssStatThrottledFtraceEventDefaultTypeInternalperfetto::protos::RssStatThrottledFtraceEventDefaultTypeInternal34 ~RssStatThrottledFtraceEventDefaultTypeInternal() {}
35 union { // NOLINT(misc-non-private-member-variables-in-classes)
36 RssStatThrottledFtraceEvent _instance;
37 };
38 };
39 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RssStatThrottledFtraceEventDefaultTypeInternal _RssStatThrottledFtraceEvent_default_instance_;
SuspendResumeMinimalFtraceEvent(::_pbi::ConstantInitialized)40 PROTOBUF_CONSTEXPR SuspendResumeMinimalFtraceEvent::SuspendResumeMinimalFtraceEvent(
41 ::_pbi::ConstantInitialized): _impl_{
42 /*decltype(_impl_._has_bits_)*/{}
43 , /*decltype(_impl_._cached_size_)*/{}
44 , /*decltype(_impl_.start_)*/0u} {}
45 struct SuspendResumeMinimalFtraceEventDefaultTypeInternal {
SuspendResumeMinimalFtraceEventDefaultTypeInternalperfetto::protos::SuspendResumeMinimalFtraceEventDefaultTypeInternal46 PROTOBUF_CONSTEXPR SuspendResumeMinimalFtraceEventDefaultTypeInternal()
47 : _instance(::_pbi::ConstantInitialized{}) {}
~SuspendResumeMinimalFtraceEventDefaultTypeInternalperfetto::protos::SuspendResumeMinimalFtraceEventDefaultTypeInternal48 ~SuspendResumeMinimalFtraceEventDefaultTypeInternal() {}
49 union { // NOLINT(misc-non-private-member-variables-in-classes)
50 SuspendResumeMinimalFtraceEvent _instance;
51 };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SuspendResumeMinimalFtraceEventDefaultTypeInternal _SuspendResumeMinimalFtraceEvent_default_instance_;
54 } // namespace protos
55 } // namespace perfetto
56 namespace perfetto {
57 namespace protos {
58
59 // ===================================================================
60
61 class RssStatThrottledFtraceEvent::_Internal {
62 public:
63 using HasBits = decltype(std::declval<RssStatThrottledFtraceEvent>()._impl_._has_bits_);
set_has_curr(HasBits * has_bits)64 static void set_has_curr(HasBits* has_bits) {
65 (*has_bits)[0] |= 1u;
66 }
set_has_member(HasBits * has_bits)67 static void set_has_member(HasBits* has_bits) {
68 (*has_bits)[0] |= 2u;
69 }
set_has_mm_id(HasBits * has_bits)70 static void set_has_mm_id(HasBits* has_bits) {
71 (*has_bits)[0] |= 8u;
72 }
set_has_size(HasBits * has_bits)73 static void set_has_size(HasBits* has_bits) {
74 (*has_bits)[0] |= 4u;
75 }
76 };
77
RssStatThrottledFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)78 RssStatThrottledFtraceEvent::RssStatThrottledFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
79 bool is_message_owned)
80 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
81 SharedCtor(arena, is_message_owned);
82 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RssStatThrottledFtraceEvent)
83 }
RssStatThrottledFtraceEvent(const RssStatThrottledFtraceEvent & from)84 RssStatThrottledFtraceEvent::RssStatThrottledFtraceEvent(const RssStatThrottledFtraceEvent& from)
85 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
86 RssStatThrottledFtraceEvent* const _this = this; (void)_this;
87 new (&_impl_) Impl_{
88 decltype(_impl_._has_bits_){from._impl_._has_bits_}
89 , /*decltype(_impl_._cached_size_)*/{}
90 , decltype(_impl_.curr_){}
91 , decltype(_impl_.member_){}
92 , decltype(_impl_.size_){}
93 , decltype(_impl_.mm_id_){}};
94
95 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
96 ::memcpy(&_impl_.curr_, &from._impl_.curr_,
97 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.mm_id_) -
98 reinterpret_cast<char*>(&_impl_.curr_)) + sizeof(_impl_.mm_id_));
99 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RssStatThrottledFtraceEvent)
100 }
101
SharedCtor(::_pb::Arena * arena,bool is_message_owned)102 inline void RssStatThrottledFtraceEvent::SharedCtor(
103 ::_pb::Arena* arena, bool is_message_owned) {
104 (void)arena;
105 (void)is_message_owned;
106 new (&_impl_) Impl_{
107 decltype(_impl_._has_bits_){}
108 , /*decltype(_impl_._cached_size_)*/{}
109 , decltype(_impl_.curr_){0u}
110 , decltype(_impl_.member_){0}
111 , decltype(_impl_.size_){::int64_t{0}}
112 , decltype(_impl_.mm_id_){0u}
113 };
114 }
115
~RssStatThrottledFtraceEvent()116 RssStatThrottledFtraceEvent::~RssStatThrottledFtraceEvent() {
117 // @@protoc_insertion_point(destructor:perfetto.protos.RssStatThrottledFtraceEvent)
118 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
119 (void)arena;
120 return;
121 }
122 SharedDtor();
123 }
124
SharedDtor()125 inline void RssStatThrottledFtraceEvent::SharedDtor() {
126 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
127 }
128
SetCachedSize(int size) const129 void RssStatThrottledFtraceEvent::SetCachedSize(int size) const {
130 _impl_._cached_size_.Set(size);
131 }
132
Clear()133 void RssStatThrottledFtraceEvent::Clear() {
134 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RssStatThrottledFtraceEvent)
135 ::uint32_t cached_has_bits = 0;
136 // Prevent compiler warnings about cached_has_bits being unused
137 (void) cached_has_bits;
138
139 cached_has_bits = _impl_._has_bits_[0];
140 if (cached_has_bits & 0x0000000fu) {
141 ::memset(&_impl_.curr_, 0, static_cast<size_t>(
142 reinterpret_cast<char*>(&_impl_.mm_id_) -
143 reinterpret_cast<char*>(&_impl_.curr_)) + sizeof(_impl_.mm_id_));
144 }
145 _impl_._has_bits_.Clear();
146 _internal_metadata_.Clear<std::string>();
147 }
148
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)149 const char* RssStatThrottledFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
150 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
151 _Internal::HasBits has_bits{};
152 while (!ctx->Done(&ptr)) {
153 ::uint32_t tag;
154 ptr = ::_pbi::ReadTag(ptr, &tag);
155 switch (tag >> 3) {
156 // optional uint32 curr = 1;
157 case 1:
158 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
159 _Internal::set_has_curr(&has_bits);
160 _impl_.curr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
161 CHK_(ptr);
162 } else {
163 goto handle_unusual;
164 }
165 continue;
166 // optional int32 member = 2;
167 case 2:
168 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
169 _Internal::set_has_member(&has_bits);
170 _impl_.member_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
171 CHK_(ptr);
172 } else {
173 goto handle_unusual;
174 }
175 continue;
176 // optional uint32 mm_id = 3;
177 case 3:
178 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
179 _Internal::set_has_mm_id(&has_bits);
180 _impl_.mm_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
181 CHK_(ptr);
182 } else {
183 goto handle_unusual;
184 }
185 continue;
186 // optional int64 size = 4;
187 case 4:
188 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
189 _Internal::set_has_size(&has_bits);
190 _impl_.size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
191 CHK_(ptr);
192 } else {
193 goto handle_unusual;
194 }
195 continue;
196 default:
197 goto handle_unusual;
198 } // switch
199 handle_unusual:
200 if ((tag == 0) || ((tag & 7) == 4)) {
201 CHK_(ptr);
202 ctx->SetLastTag(tag);
203 goto message_done;
204 }
205 ptr = UnknownFieldParse(
206 tag,
207 _internal_metadata_.mutable_unknown_fields<std::string>(),
208 ptr, ctx);
209 CHK_(ptr != nullptr);
210 } // while
211 message_done:
212 _impl_._has_bits_.Or(has_bits);
213 return ptr;
214 failure:
215 ptr = nullptr;
216 goto message_done;
217 #undef CHK_
218 }
219
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const220 ::uint8_t* RssStatThrottledFtraceEvent::_InternalSerialize(
221 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
222 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RssStatThrottledFtraceEvent)
223 ::uint32_t cached_has_bits = 0;
224 (void) cached_has_bits;
225
226 cached_has_bits = _impl_._has_bits_[0];
227 // optional uint32 curr = 1;
228 if (cached_has_bits & 0x00000001u) {
229 target = stream->EnsureSpace(target);
230 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_curr(), target);
231 }
232
233 // optional int32 member = 2;
234 if (cached_has_bits & 0x00000002u) {
235 target = stream->EnsureSpace(target);
236 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_member(), target);
237 }
238
239 // optional uint32 mm_id = 3;
240 if (cached_has_bits & 0x00000008u) {
241 target = stream->EnsureSpace(target);
242 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_mm_id(), target);
243 }
244
245 // optional int64 size = 4;
246 if (cached_has_bits & 0x00000004u) {
247 target = stream->EnsureSpace(target);
248 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_size(), target);
249 }
250
251 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
252 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
253 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
254 }
255 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RssStatThrottledFtraceEvent)
256 return target;
257 }
258
ByteSizeLong() const259 size_t RssStatThrottledFtraceEvent::ByteSizeLong() const {
260 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RssStatThrottledFtraceEvent)
261 size_t total_size = 0;
262
263 ::uint32_t cached_has_bits = 0;
264 // Prevent compiler warnings about cached_has_bits being unused
265 (void) cached_has_bits;
266
267 cached_has_bits = _impl_._has_bits_[0];
268 if (cached_has_bits & 0x0000000fu) {
269 // optional uint32 curr = 1;
270 if (cached_has_bits & 0x00000001u) {
271 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_curr());
272 }
273
274 // optional int32 member = 2;
275 if (cached_has_bits & 0x00000002u) {
276 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_member());
277 }
278
279 // optional int64 size = 4;
280 if (cached_has_bits & 0x00000004u) {
281 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_size());
282 }
283
284 // optional uint32 mm_id = 3;
285 if (cached_has_bits & 0x00000008u) {
286 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mm_id());
287 }
288
289 }
290 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
291 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
292 }
293 int cached_size = ::_pbi::ToCachedSize(total_size);
294 SetCachedSize(cached_size);
295 return total_size;
296 }
297
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)298 void RssStatThrottledFtraceEvent::CheckTypeAndMergeFrom(
299 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
300 MergeFrom(*::_pbi::DownCast<const RssStatThrottledFtraceEvent*>(
301 &from));
302 }
303
MergeFrom(const RssStatThrottledFtraceEvent & from)304 void RssStatThrottledFtraceEvent::MergeFrom(const RssStatThrottledFtraceEvent& from) {
305 RssStatThrottledFtraceEvent* const _this = this;
306 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RssStatThrottledFtraceEvent)
307 GOOGLE_DCHECK_NE(&from, _this);
308 ::uint32_t cached_has_bits = 0;
309 (void) cached_has_bits;
310
311 cached_has_bits = from._impl_._has_bits_[0];
312 if (cached_has_bits & 0x0000000fu) {
313 if (cached_has_bits & 0x00000001u) {
314 _this->_impl_.curr_ = from._impl_.curr_;
315 }
316 if (cached_has_bits & 0x00000002u) {
317 _this->_impl_.member_ = from._impl_.member_;
318 }
319 if (cached_has_bits & 0x00000004u) {
320 _this->_impl_.size_ = from._impl_.size_;
321 }
322 if (cached_has_bits & 0x00000008u) {
323 _this->_impl_.mm_id_ = from._impl_.mm_id_;
324 }
325 _this->_impl_._has_bits_[0] |= cached_has_bits;
326 }
327 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
328 }
329
CopyFrom(const RssStatThrottledFtraceEvent & from)330 void RssStatThrottledFtraceEvent::CopyFrom(const RssStatThrottledFtraceEvent& from) {
331 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RssStatThrottledFtraceEvent)
332 if (&from == this) return;
333 Clear();
334 MergeFrom(from);
335 }
336
IsInitialized() const337 bool RssStatThrottledFtraceEvent::IsInitialized() const {
338 return true;
339 }
340
InternalSwap(RssStatThrottledFtraceEvent * other)341 void RssStatThrottledFtraceEvent::InternalSwap(RssStatThrottledFtraceEvent* other) {
342 using std::swap;
343 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
344 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
345 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
346 PROTOBUF_FIELD_OFFSET(RssStatThrottledFtraceEvent, _impl_.mm_id_)
347 + sizeof(RssStatThrottledFtraceEvent::_impl_.mm_id_) // NOLINT
348 - PROTOBUF_FIELD_OFFSET(RssStatThrottledFtraceEvent, _impl_.curr_)>(
349 reinterpret_cast<char*>(&_impl_.curr_),
350 reinterpret_cast<char*>(&other->_impl_.curr_));
351 }
352
GetTypeName() const353 std::string RssStatThrottledFtraceEvent::GetTypeName() const {
354 return "perfetto.protos.RssStatThrottledFtraceEvent";
355 }
356
357
358 // ===================================================================
359
360 class SuspendResumeMinimalFtraceEvent::_Internal {
361 public:
362 using HasBits = decltype(std::declval<SuspendResumeMinimalFtraceEvent>()._impl_._has_bits_);
set_has_start(HasBits * has_bits)363 static void set_has_start(HasBits* has_bits) {
364 (*has_bits)[0] |= 1u;
365 }
366 };
367
SuspendResumeMinimalFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)368 SuspendResumeMinimalFtraceEvent::SuspendResumeMinimalFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
369 bool is_message_owned)
370 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
371 SharedCtor(arena, is_message_owned);
372 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SuspendResumeMinimalFtraceEvent)
373 }
SuspendResumeMinimalFtraceEvent(const SuspendResumeMinimalFtraceEvent & from)374 SuspendResumeMinimalFtraceEvent::SuspendResumeMinimalFtraceEvent(const SuspendResumeMinimalFtraceEvent& from)
375 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
376 SuspendResumeMinimalFtraceEvent* const _this = this; (void)_this;
377 new (&_impl_) Impl_{
378 decltype(_impl_._has_bits_){from._impl_._has_bits_}
379 , /*decltype(_impl_._cached_size_)*/{}
380 , decltype(_impl_.start_){}};
381
382 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
383 _this->_impl_.start_ = from._impl_.start_;
384 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SuspendResumeMinimalFtraceEvent)
385 }
386
SharedCtor(::_pb::Arena * arena,bool is_message_owned)387 inline void SuspendResumeMinimalFtraceEvent::SharedCtor(
388 ::_pb::Arena* arena, bool is_message_owned) {
389 (void)arena;
390 (void)is_message_owned;
391 new (&_impl_) Impl_{
392 decltype(_impl_._has_bits_){}
393 , /*decltype(_impl_._cached_size_)*/{}
394 , decltype(_impl_.start_){0u}
395 };
396 }
397
~SuspendResumeMinimalFtraceEvent()398 SuspendResumeMinimalFtraceEvent::~SuspendResumeMinimalFtraceEvent() {
399 // @@protoc_insertion_point(destructor:perfetto.protos.SuspendResumeMinimalFtraceEvent)
400 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
401 (void)arena;
402 return;
403 }
404 SharedDtor();
405 }
406
SharedDtor()407 inline void SuspendResumeMinimalFtraceEvent::SharedDtor() {
408 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
409 }
410
SetCachedSize(int size) const411 void SuspendResumeMinimalFtraceEvent::SetCachedSize(int size) const {
412 _impl_._cached_size_.Set(size);
413 }
414
Clear()415 void SuspendResumeMinimalFtraceEvent::Clear() {
416 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SuspendResumeMinimalFtraceEvent)
417 ::uint32_t cached_has_bits = 0;
418 // Prevent compiler warnings about cached_has_bits being unused
419 (void) cached_has_bits;
420
421 _impl_.start_ = 0u;
422 _impl_._has_bits_.Clear();
423 _internal_metadata_.Clear<std::string>();
424 }
425
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)426 const char* SuspendResumeMinimalFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
427 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
428 _Internal::HasBits has_bits{};
429 while (!ctx->Done(&ptr)) {
430 ::uint32_t tag;
431 ptr = ::_pbi::ReadTag(ptr, &tag);
432 switch (tag >> 3) {
433 // optional uint32 start = 1;
434 case 1:
435 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
436 _Internal::set_has_start(&has_bits);
437 _impl_.start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
438 CHK_(ptr);
439 } else {
440 goto handle_unusual;
441 }
442 continue;
443 default:
444 goto handle_unusual;
445 } // switch
446 handle_unusual:
447 if ((tag == 0) || ((tag & 7) == 4)) {
448 CHK_(ptr);
449 ctx->SetLastTag(tag);
450 goto message_done;
451 }
452 ptr = UnknownFieldParse(
453 tag,
454 _internal_metadata_.mutable_unknown_fields<std::string>(),
455 ptr, ctx);
456 CHK_(ptr != nullptr);
457 } // while
458 message_done:
459 _impl_._has_bits_.Or(has_bits);
460 return ptr;
461 failure:
462 ptr = nullptr;
463 goto message_done;
464 #undef CHK_
465 }
466
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const467 ::uint8_t* SuspendResumeMinimalFtraceEvent::_InternalSerialize(
468 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
469 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SuspendResumeMinimalFtraceEvent)
470 ::uint32_t cached_has_bits = 0;
471 (void) cached_has_bits;
472
473 cached_has_bits = _impl_._has_bits_[0];
474 // optional uint32 start = 1;
475 if (cached_has_bits & 0x00000001u) {
476 target = stream->EnsureSpace(target);
477 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_start(), target);
478 }
479
480 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
481 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
482 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
483 }
484 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SuspendResumeMinimalFtraceEvent)
485 return target;
486 }
487
ByteSizeLong() const488 size_t SuspendResumeMinimalFtraceEvent::ByteSizeLong() const {
489 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SuspendResumeMinimalFtraceEvent)
490 size_t total_size = 0;
491
492 ::uint32_t cached_has_bits = 0;
493 // Prevent compiler warnings about cached_has_bits being unused
494 (void) cached_has_bits;
495
496 // optional uint32 start = 1;
497 cached_has_bits = _impl_._has_bits_[0];
498 if (cached_has_bits & 0x00000001u) {
499 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_start());
500 }
501
502 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
503 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
504 }
505 int cached_size = ::_pbi::ToCachedSize(total_size);
506 SetCachedSize(cached_size);
507 return total_size;
508 }
509
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)510 void SuspendResumeMinimalFtraceEvent::CheckTypeAndMergeFrom(
511 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
512 MergeFrom(*::_pbi::DownCast<const SuspendResumeMinimalFtraceEvent*>(
513 &from));
514 }
515
MergeFrom(const SuspendResumeMinimalFtraceEvent & from)516 void SuspendResumeMinimalFtraceEvent::MergeFrom(const SuspendResumeMinimalFtraceEvent& from) {
517 SuspendResumeMinimalFtraceEvent* const _this = this;
518 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SuspendResumeMinimalFtraceEvent)
519 GOOGLE_DCHECK_NE(&from, _this);
520 ::uint32_t cached_has_bits = 0;
521 (void) cached_has_bits;
522
523 if (from._internal_has_start()) {
524 _this->_internal_set_start(from._internal_start());
525 }
526 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
527 }
528
CopyFrom(const SuspendResumeMinimalFtraceEvent & from)529 void SuspendResumeMinimalFtraceEvent::CopyFrom(const SuspendResumeMinimalFtraceEvent& from) {
530 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SuspendResumeMinimalFtraceEvent)
531 if (&from == this) return;
532 Clear();
533 MergeFrom(from);
534 }
535
IsInitialized() const536 bool SuspendResumeMinimalFtraceEvent::IsInitialized() const {
537 return true;
538 }
539
InternalSwap(SuspendResumeMinimalFtraceEvent * other)540 void SuspendResumeMinimalFtraceEvent::InternalSwap(SuspendResumeMinimalFtraceEvent* other) {
541 using std::swap;
542 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
543 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
544 swap(_impl_.start_, other->_impl_.start_);
545 }
546
GetTypeName() const547 std::string SuspendResumeMinimalFtraceEvent::GetTypeName() const {
548 return "perfetto.protos.SuspendResumeMinimalFtraceEvent";
549 }
550
551
552 // @@protoc_insertion_point(namespace_scope)
553 } // namespace protos
554 } // namespace perfetto
555 PROTOBUF_NAMESPACE_OPEN
556 template<> PROTOBUF_NOINLINE ::perfetto::protos::RssStatThrottledFtraceEvent*
CreateMaybeMessage(Arena * arena)557 Arena::CreateMaybeMessage< ::perfetto::protos::RssStatThrottledFtraceEvent >(Arena* arena) {
558 return Arena::CreateMessageInternal< ::perfetto::protos::RssStatThrottledFtraceEvent >(arena);
559 }
560 template<> PROTOBUF_NOINLINE ::perfetto::protos::SuspendResumeMinimalFtraceEvent*
CreateMaybeMessage(Arena * arena)561 Arena::CreateMaybeMessage< ::perfetto::protos::SuspendResumeMinimalFtraceEvent >(Arena* arena) {
562 return Arena::CreateMessageInternal< ::perfetto::protos::SuspendResumeMinimalFtraceEvent >(arena);
563 }
564 PROTOBUF_NAMESPACE_CLOSE
565
566 // @@protoc_insertion_point(global_scope)
567 #include <google/protobuf/port_undef.inc>
568