1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/dma_fence.proto
3
4 #include "protos/perfetto/trace/ftrace/dma_fence.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 {
DmaFenceInitFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR DmaFenceInitFtraceEvent::DmaFenceInitFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28 , /*decltype(_impl_.timeline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29 , /*decltype(_impl_.context_)*/0u
30 , /*decltype(_impl_.seqno_)*/0u} {}
31 struct DmaFenceInitFtraceEventDefaultTypeInternal {
DmaFenceInitFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceInitFtraceEventDefaultTypeInternal32 PROTOBUF_CONSTEXPR DmaFenceInitFtraceEventDefaultTypeInternal()
33 : _instance(::_pbi::ConstantInitialized{}) {}
~DmaFenceInitFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceInitFtraceEventDefaultTypeInternal34 ~DmaFenceInitFtraceEventDefaultTypeInternal() {}
35 union { // NOLINT(misc-non-private-member-variables-in-classes)
36 DmaFenceInitFtraceEvent _instance;
37 };
38 };
39 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DmaFenceInitFtraceEventDefaultTypeInternal _DmaFenceInitFtraceEvent_default_instance_;
DmaFenceEmitFtraceEvent(::_pbi::ConstantInitialized)40 PROTOBUF_CONSTEXPR DmaFenceEmitFtraceEvent::DmaFenceEmitFtraceEvent(
41 ::_pbi::ConstantInitialized): _impl_{
42 /*decltype(_impl_._has_bits_)*/{}
43 , /*decltype(_impl_._cached_size_)*/{}
44 , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
45 , /*decltype(_impl_.timeline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
46 , /*decltype(_impl_.context_)*/0u
47 , /*decltype(_impl_.seqno_)*/0u} {}
48 struct DmaFenceEmitFtraceEventDefaultTypeInternal {
DmaFenceEmitFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceEmitFtraceEventDefaultTypeInternal49 PROTOBUF_CONSTEXPR DmaFenceEmitFtraceEventDefaultTypeInternal()
50 : _instance(::_pbi::ConstantInitialized{}) {}
~DmaFenceEmitFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceEmitFtraceEventDefaultTypeInternal51 ~DmaFenceEmitFtraceEventDefaultTypeInternal() {}
52 union { // NOLINT(misc-non-private-member-variables-in-classes)
53 DmaFenceEmitFtraceEvent _instance;
54 };
55 };
56 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DmaFenceEmitFtraceEventDefaultTypeInternal _DmaFenceEmitFtraceEvent_default_instance_;
DmaFenceSignaledFtraceEvent(::_pbi::ConstantInitialized)57 PROTOBUF_CONSTEXPR DmaFenceSignaledFtraceEvent::DmaFenceSignaledFtraceEvent(
58 ::_pbi::ConstantInitialized): _impl_{
59 /*decltype(_impl_._has_bits_)*/{}
60 , /*decltype(_impl_._cached_size_)*/{}
61 , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
62 , /*decltype(_impl_.timeline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
63 , /*decltype(_impl_.context_)*/0u
64 , /*decltype(_impl_.seqno_)*/0u} {}
65 struct DmaFenceSignaledFtraceEventDefaultTypeInternal {
DmaFenceSignaledFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceSignaledFtraceEventDefaultTypeInternal66 PROTOBUF_CONSTEXPR DmaFenceSignaledFtraceEventDefaultTypeInternal()
67 : _instance(::_pbi::ConstantInitialized{}) {}
~DmaFenceSignaledFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceSignaledFtraceEventDefaultTypeInternal68 ~DmaFenceSignaledFtraceEventDefaultTypeInternal() {}
69 union { // NOLINT(misc-non-private-member-variables-in-classes)
70 DmaFenceSignaledFtraceEvent _instance;
71 };
72 };
73 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DmaFenceSignaledFtraceEventDefaultTypeInternal _DmaFenceSignaledFtraceEvent_default_instance_;
DmaFenceWaitStartFtraceEvent(::_pbi::ConstantInitialized)74 PROTOBUF_CONSTEXPR DmaFenceWaitStartFtraceEvent::DmaFenceWaitStartFtraceEvent(
75 ::_pbi::ConstantInitialized): _impl_{
76 /*decltype(_impl_._has_bits_)*/{}
77 , /*decltype(_impl_._cached_size_)*/{}
78 , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
79 , /*decltype(_impl_.timeline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
80 , /*decltype(_impl_.context_)*/0u
81 , /*decltype(_impl_.seqno_)*/0u} {}
82 struct DmaFenceWaitStartFtraceEventDefaultTypeInternal {
DmaFenceWaitStartFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceWaitStartFtraceEventDefaultTypeInternal83 PROTOBUF_CONSTEXPR DmaFenceWaitStartFtraceEventDefaultTypeInternal()
84 : _instance(::_pbi::ConstantInitialized{}) {}
~DmaFenceWaitStartFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceWaitStartFtraceEventDefaultTypeInternal85 ~DmaFenceWaitStartFtraceEventDefaultTypeInternal() {}
86 union { // NOLINT(misc-non-private-member-variables-in-classes)
87 DmaFenceWaitStartFtraceEvent _instance;
88 };
89 };
90 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DmaFenceWaitStartFtraceEventDefaultTypeInternal _DmaFenceWaitStartFtraceEvent_default_instance_;
DmaFenceWaitEndFtraceEvent(::_pbi::ConstantInitialized)91 PROTOBUF_CONSTEXPR DmaFenceWaitEndFtraceEvent::DmaFenceWaitEndFtraceEvent(
92 ::_pbi::ConstantInitialized): _impl_{
93 /*decltype(_impl_._has_bits_)*/{}
94 , /*decltype(_impl_._cached_size_)*/{}
95 , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
96 , /*decltype(_impl_.timeline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
97 , /*decltype(_impl_.context_)*/0u
98 , /*decltype(_impl_.seqno_)*/0u} {}
99 struct DmaFenceWaitEndFtraceEventDefaultTypeInternal {
DmaFenceWaitEndFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceWaitEndFtraceEventDefaultTypeInternal100 PROTOBUF_CONSTEXPR DmaFenceWaitEndFtraceEventDefaultTypeInternal()
101 : _instance(::_pbi::ConstantInitialized{}) {}
~DmaFenceWaitEndFtraceEventDefaultTypeInternalperfetto::protos::DmaFenceWaitEndFtraceEventDefaultTypeInternal102 ~DmaFenceWaitEndFtraceEventDefaultTypeInternal() {}
103 union { // NOLINT(misc-non-private-member-variables-in-classes)
104 DmaFenceWaitEndFtraceEvent _instance;
105 };
106 };
107 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DmaFenceWaitEndFtraceEventDefaultTypeInternal _DmaFenceWaitEndFtraceEvent_default_instance_;
108 } // namespace protos
109 } // namespace perfetto
110 namespace perfetto {
111 namespace protos {
112
113 // ===================================================================
114
115 class DmaFenceInitFtraceEvent::_Internal {
116 public:
117 using HasBits = decltype(std::declval<DmaFenceInitFtraceEvent>()._impl_._has_bits_);
set_has_context(HasBits * has_bits)118 static void set_has_context(HasBits* has_bits) {
119 (*has_bits)[0] |= 4u;
120 }
set_has_driver(HasBits * has_bits)121 static void set_has_driver(HasBits* has_bits) {
122 (*has_bits)[0] |= 1u;
123 }
set_has_seqno(HasBits * has_bits)124 static void set_has_seqno(HasBits* has_bits) {
125 (*has_bits)[0] |= 8u;
126 }
set_has_timeline(HasBits * has_bits)127 static void set_has_timeline(HasBits* has_bits) {
128 (*has_bits)[0] |= 2u;
129 }
130 };
131
DmaFenceInitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)132 DmaFenceInitFtraceEvent::DmaFenceInitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
133 bool is_message_owned)
134 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
135 SharedCtor(arena, is_message_owned);
136 // @@protoc_insertion_point(arena_constructor:perfetto.protos.DmaFenceInitFtraceEvent)
137 }
DmaFenceInitFtraceEvent(const DmaFenceInitFtraceEvent & from)138 DmaFenceInitFtraceEvent::DmaFenceInitFtraceEvent(const DmaFenceInitFtraceEvent& from)
139 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
140 DmaFenceInitFtraceEvent* const _this = this; (void)_this;
141 new (&_impl_) Impl_{
142 decltype(_impl_._has_bits_){from._impl_._has_bits_}
143 , /*decltype(_impl_._cached_size_)*/{}
144 , decltype(_impl_.driver_){}
145 , decltype(_impl_.timeline_){}
146 , decltype(_impl_.context_){}
147 , decltype(_impl_.seqno_){}};
148
149 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
150 _impl_.driver_.InitDefault();
151 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
152 _impl_.driver_.Set("", GetArenaForAllocation());
153 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
154 if (from._internal_has_driver()) {
155 _this->_impl_.driver_.Set(from._internal_driver(),
156 _this->GetArenaForAllocation());
157 }
158 _impl_.timeline_.InitDefault();
159 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
160 _impl_.timeline_.Set("", GetArenaForAllocation());
161 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
162 if (from._internal_has_timeline()) {
163 _this->_impl_.timeline_.Set(from._internal_timeline(),
164 _this->GetArenaForAllocation());
165 }
166 ::memcpy(&_impl_.context_, &from._impl_.context_,
167 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.seqno_) -
168 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
169 // @@protoc_insertion_point(copy_constructor:perfetto.protos.DmaFenceInitFtraceEvent)
170 }
171
SharedCtor(::_pb::Arena * arena,bool is_message_owned)172 inline void DmaFenceInitFtraceEvent::SharedCtor(
173 ::_pb::Arena* arena, bool is_message_owned) {
174 (void)arena;
175 (void)is_message_owned;
176 new (&_impl_) Impl_{
177 decltype(_impl_._has_bits_){}
178 , /*decltype(_impl_._cached_size_)*/{}
179 , decltype(_impl_.driver_){}
180 , decltype(_impl_.timeline_){}
181 , decltype(_impl_.context_){0u}
182 , decltype(_impl_.seqno_){0u}
183 };
184 _impl_.driver_.InitDefault();
185 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
186 _impl_.driver_.Set("", GetArenaForAllocation());
187 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
188 _impl_.timeline_.InitDefault();
189 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
190 _impl_.timeline_.Set("", GetArenaForAllocation());
191 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
192 }
193
~DmaFenceInitFtraceEvent()194 DmaFenceInitFtraceEvent::~DmaFenceInitFtraceEvent() {
195 // @@protoc_insertion_point(destructor:perfetto.protos.DmaFenceInitFtraceEvent)
196 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
197 (void)arena;
198 return;
199 }
200 SharedDtor();
201 }
202
SharedDtor()203 inline void DmaFenceInitFtraceEvent::SharedDtor() {
204 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
205 _impl_.driver_.Destroy();
206 _impl_.timeline_.Destroy();
207 }
208
SetCachedSize(int size) const209 void DmaFenceInitFtraceEvent::SetCachedSize(int size) const {
210 _impl_._cached_size_.Set(size);
211 }
212
Clear()213 void DmaFenceInitFtraceEvent::Clear() {
214 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DmaFenceInitFtraceEvent)
215 ::uint32_t cached_has_bits = 0;
216 // Prevent compiler warnings about cached_has_bits being unused
217 (void) cached_has_bits;
218
219 cached_has_bits = _impl_._has_bits_[0];
220 if (cached_has_bits & 0x00000003u) {
221 if (cached_has_bits & 0x00000001u) {
222 _impl_.driver_.ClearNonDefaultToEmpty();
223 }
224 if (cached_has_bits & 0x00000002u) {
225 _impl_.timeline_.ClearNonDefaultToEmpty();
226 }
227 }
228 if (cached_has_bits & 0x0000000cu) {
229 ::memset(&_impl_.context_, 0, static_cast<size_t>(
230 reinterpret_cast<char*>(&_impl_.seqno_) -
231 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
232 }
233 _impl_._has_bits_.Clear();
234 _internal_metadata_.Clear<std::string>();
235 }
236
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)237 const char* DmaFenceInitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
238 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
239 _Internal::HasBits has_bits{};
240 while (!ctx->Done(&ptr)) {
241 ::uint32_t tag;
242 ptr = ::_pbi::ReadTag(ptr, &tag);
243 switch (tag >> 3) {
244 // optional uint32 context = 1;
245 case 1:
246 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
247 _Internal::set_has_context(&has_bits);
248 _impl_.context_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
249 CHK_(ptr);
250 } else {
251 goto handle_unusual;
252 }
253 continue;
254 // optional string driver = 2;
255 case 2:
256 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
257 auto str = _internal_mutable_driver();
258 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
259 CHK_(ptr);
260 } else {
261 goto handle_unusual;
262 }
263 continue;
264 // optional uint32 seqno = 3;
265 case 3:
266 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
267 _Internal::set_has_seqno(&has_bits);
268 _impl_.seqno_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
269 CHK_(ptr);
270 } else {
271 goto handle_unusual;
272 }
273 continue;
274 // optional string timeline = 4;
275 case 4:
276 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
277 auto str = _internal_mutable_timeline();
278 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
279 CHK_(ptr);
280 } else {
281 goto handle_unusual;
282 }
283 continue;
284 default:
285 goto handle_unusual;
286 } // switch
287 handle_unusual:
288 if ((tag == 0) || ((tag & 7) == 4)) {
289 CHK_(ptr);
290 ctx->SetLastTag(tag);
291 goto message_done;
292 }
293 ptr = UnknownFieldParse(
294 tag,
295 _internal_metadata_.mutable_unknown_fields<std::string>(),
296 ptr, ctx);
297 CHK_(ptr != nullptr);
298 } // while
299 message_done:
300 _impl_._has_bits_.Or(has_bits);
301 return ptr;
302 failure:
303 ptr = nullptr;
304 goto message_done;
305 #undef CHK_
306 }
307
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const308 ::uint8_t* DmaFenceInitFtraceEvent::_InternalSerialize(
309 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
310 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DmaFenceInitFtraceEvent)
311 ::uint32_t cached_has_bits = 0;
312 (void) cached_has_bits;
313
314 cached_has_bits = _impl_._has_bits_[0];
315 // optional uint32 context = 1;
316 if (cached_has_bits & 0x00000004u) {
317 target = stream->EnsureSpace(target);
318 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_context(), target);
319 }
320
321 // optional string driver = 2;
322 if (cached_has_bits & 0x00000001u) {
323 target = stream->WriteStringMaybeAliased(
324 2, this->_internal_driver(), target);
325 }
326
327 // optional uint32 seqno = 3;
328 if (cached_has_bits & 0x00000008u) {
329 target = stream->EnsureSpace(target);
330 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_seqno(), target);
331 }
332
333 // optional string timeline = 4;
334 if (cached_has_bits & 0x00000002u) {
335 target = stream->WriteStringMaybeAliased(
336 4, this->_internal_timeline(), target);
337 }
338
339 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
340 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
341 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
342 }
343 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DmaFenceInitFtraceEvent)
344 return target;
345 }
346
ByteSizeLong() const347 size_t DmaFenceInitFtraceEvent::ByteSizeLong() const {
348 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DmaFenceInitFtraceEvent)
349 size_t total_size = 0;
350
351 ::uint32_t cached_has_bits = 0;
352 // Prevent compiler warnings about cached_has_bits being unused
353 (void) cached_has_bits;
354
355 cached_has_bits = _impl_._has_bits_[0];
356 if (cached_has_bits & 0x0000000fu) {
357 // optional string driver = 2;
358 if (cached_has_bits & 0x00000001u) {
359 total_size += 1 +
360 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
361 this->_internal_driver());
362 }
363
364 // optional string timeline = 4;
365 if (cached_has_bits & 0x00000002u) {
366 total_size += 1 +
367 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
368 this->_internal_timeline());
369 }
370
371 // optional uint32 context = 1;
372 if (cached_has_bits & 0x00000004u) {
373 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_context());
374 }
375
376 // optional uint32 seqno = 3;
377 if (cached_has_bits & 0x00000008u) {
378 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seqno());
379 }
380
381 }
382 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
383 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
384 }
385 int cached_size = ::_pbi::ToCachedSize(total_size);
386 SetCachedSize(cached_size);
387 return total_size;
388 }
389
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)390 void DmaFenceInitFtraceEvent::CheckTypeAndMergeFrom(
391 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
392 MergeFrom(*::_pbi::DownCast<const DmaFenceInitFtraceEvent*>(
393 &from));
394 }
395
MergeFrom(const DmaFenceInitFtraceEvent & from)396 void DmaFenceInitFtraceEvent::MergeFrom(const DmaFenceInitFtraceEvent& from) {
397 DmaFenceInitFtraceEvent* const _this = this;
398 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DmaFenceInitFtraceEvent)
399 GOOGLE_DCHECK_NE(&from, _this);
400 ::uint32_t cached_has_bits = 0;
401 (void) cached_has_bits;
402
403 cached_has_bits = from._impl_._has_bits_[0];
404 if (cached_has_bits & 0x0000000fu) {
405 if (cached_has_bits & 0x00000001u) {
406 _this->_internal_set_driver(from._internal_driver());
407 }
408 if (cached_has_bits & 0x00000002u) {
409 _this->_internal_set_timeline(from._internal_timeline());
410 }
411 if (cached_has_bits & 0x00000004u) {
412 _this->_impl_.context_ = from._impl_.context_;
413 }
414 if (cached_has_bits & 0x00000008u) {
415 _this->_impl_.seqno_ = from._impl_.seqno_;
416 }
417 _this->_impl_._has_bits_[0] |= cached_has_bits;
418 }
419 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
420 }
421
CopyFrom(const DmaFenceInitFtraceEvent & from)422 void DmaFenceInitFtraceEvent::CopyFrom(const DmaFenceInitFtraceEvent& from) {
423 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DmaFenceInitFtraceEvent)
424 if (&from == this) return;
425 Clear();
426 MergeFrom(from);
427 }
428
IsInitialized() const429 bool DmaFenceInitFtraceEvent::IsInitialized() const {
430 return true;
431 }
432
InternalSwap(DmaFenceInitFtraceEvent * other)433 void DmaFenceInitFtraceEvent::InternalSwap(DmaFenceInitFtraceEvent* other) {
434 using std::swap;
435 auto* lhs_arena = GetArenaForAllocation();
436 auto* rhs_arena = other->GetArenaForAllocation();
437 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
438 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
439 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
440 &_impl_.driver_, lhs_arena,
441 &other->_impl_.driver_, rhs_arena
442 );
443 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
444 &_impl_.timeline_, lhs_arena,
445 &other->_impl_.timeline_, rhs_arena
446 );
447 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
448 PROTOBUF_FIELD_OFFSET(DmaFenceInitFtraceEvent, _impl_.seqno_)
449 + sizeof(DmaFenceInitFtraceEvent::_impl_.seqno_) // NOLINT
450 - PROTOBUF_FIELD_OFFSET(DmaFenceInitFtraceEvent, _impl_.context_)>(
451 reinterpret_cast<char*>(&_impl_.context_),
452 reinterpret_cast<char*>(&other->_impl_.context_));
453 }
454
GetTypeName() const455 std::string DmaFenceInitFtraceEvent::GetTypeName() const {
456 return "perfetto.protos.DmaFenceInitFtraceEvent";
457 }
458
459
460 // ===================================================================
461
462 class DmaFenceEmitFtraceEvent::_Internal {
463 public:
464 using HasBits = decltype(std::declval<DmaFenceEmitFtraceEvent>()._impl_._has_bits_);
set_has_context(HasBits * has_bits)465 static void set_has_context(HasBits* has_bits) {
466 (*has_bits)[0] |= 4u;
467 }
set_has_driver(HasBits * has_bits)468 static void set_has_driver(HasBits* has_bits) {
469 (*has_bits)[0] |= 1u;
470 }
set_has_seqno(HasBits * has_bits)471 static void set_has_seqno(HasBits* has_bits) {
472 (*has_bits)[0] |= 8u;
473 }
set_has_timeline(HasBits * has_bits)474 static void set_has_timeline(HasBits* has_bits) {
475 (*has_bits)[0] |= 2u;
476 }
477 };
478
DmaFenceEmitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)479 DmaFenceEmitFtraceEvent::DmaFenceEmitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
480 bool is_message_owned)
481 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
482 SharedCtor(arena, is_message_owned);
483 // @@protoc_insertion_point(arena_constructor:perfetto.protos.DmaFenceEmitFtraceEvent)
484 }
DmaFenceEmitFtraceEvent(const DmaFenceEmitFtraceEvent & from)485 DmaFenceEmitFtraceEvent::DmaFenceEmitFtraceEvent(const DmaFenceEmitFtraceEvent& from)
486 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
487 DmaFenceEmitFtraceEvent* const _this = this; (void)_this;
488 new (&_impl_) Impl_{
489 decltype(_impl_._has_bits_){from._impl_._has_bits_}
490 , /*decltype(_impl_._cached_size_)*/{}
491 , decltype(_impl_.driver_){}
492 , decltype(_impl_.timeline_){}
493 , decltype(_impl_.context_){}
494 , decltype(_impl_.seqno_){}};
495
496 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
497 _impl_.driver_.InitDefault();
498 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
499 _impl_.driver_.Set("", GetArenaForAllocation());
500 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
501 if (from._internal_has_driver()) {
502 _this->_impl_.driver_.Set(from._internal_driver(),
503 _this->GetArenaForAllocation());
504 }
505 _impl_.timeline_.InitDefault();
506 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
507 _impl_.timeline_.Set("", GetArenaForAllocation());
508 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
509 if (from._internal_has_timeline()) {
510 _this->_impl_.timeline_.Set(from._internal_timeline(),
511 _this->GetArenaForAllocation());
512 }
513 ::memcpy(&_impl_.context_, &from._impl_.context_,
514 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.seqno_) -
515 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
516 // @@protoc_insertion_point(copy_constructor:perfetto.protos.DmaFenceEmitFtraceEvent)
517 }
518
SharedCtor(::_pb::Arena * arena,bool is_message_owned)519 inline void DmaFenceEmitFtraceEvent::SharedCtor(
520 ::_pb::Arena* arena, bool is_message_owned) {
521 (void)arena;
522 (void)is_message_owned;
523 new (&_impl_) Impl_{
524 decltype(_impl_._has_bits_){}
525 , /*decltype(_impl_._cached_size_)*/{}
526 , decltype(_impl_.driver_){}
527 , decltype(_impl_.timeline_){}
528 , decltype(_impl_.context_){0u}
529 , decltype(_impl_.seqno_){0u}
530 };
531 _impl_.driver_.InitDefault();
532 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
533 _impl_.driver_.Set("", GetArenaForAllocation());
534 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
535 _impl_.timeline_.InitDefault();
536 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
537 _impl_.timeline_.Set("", GetArenaForAllocation());
538 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
539 }
540
~DmaFenceEmitFtraceEvent()541 DmaFenceEmitFtraceEvent::~DmaFenceEmitFtraceEvent() {
542 // @@protoc_insertion_point(destructor:perfetto.protos.DmaFenceEmitFtraceEvent)
543 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
544 (void)arena;
545 return;
546 }
547 SharedDtor();
548 }
549
SharedDtor()550 inline void DmaFenceEmitFtraceEvent::SharedDtor() {
551 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
552 _impl_.driver_.Destroy();
553 _impl_.timeline_.Destroy();
554 }
555
SetCachedSize(int size) const556 void DmaFenceEmitFtraceEvent::SetCachedSize(int size) const {
557 _impl_._cached_size_.Set(size);
558 }
559
Clear()560 void DmaFenceEmitFtraceEvent::Clear() {
561 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DmaFenceEmitFtraceEvent)
562 ::uint32_t cached_has_bits = 0;
563 // Prevent compiler warnings about cached_has_bits being unused
564 (void) cached_has_bits;
565
566 cached_has_bits = _impl_._has_bits_[0];
567 if (cached_has_bits & 0x00000003u) {
568 if (cached_has_bits & 0x00000001u) {
569 _impl_.driver_.ClearNonDefaultToEmpty();
570 }
571 if (cached_has_bits & 0x00000002u) {
572 _impl_.timeline_.ClearNonDefaultToEmpty();
573 }
574 }
575 if (cached_has_bits & 0x0000000cu) {
576 ::memset(&_impl_.context_, 0, static_cast<size_t>(
577 reinterpret_cast<char*>(&_impl_.seqno_) -
578 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
579 }
580 _impl_._has_bits_.Clear();
581 _internal_metadata_.Clear<std::string>();
582 }
583
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)584 const char* DmaFenceEmitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
585 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
586 _Internal::HasBits has_bits{};
587 while (!ctx->Done(&ptr)) {
588 ::uint32_t tag;
589 ptr = ::_pbi::ReadTag(ptr, &tag);
590 switch (tag >> 3) {
591 // optional uint32 context = 1;
592 case 1:
593 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
594 _Internal::set_has_context(&has_bits);
595 _impl_.context_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
596 CHK_(ptr);
597 } else {
598 goto handle_unusual;
599 }
600 continue;
601 // optional string driver = 2;
602 case 2:
603 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
604 auto str = _internal_mutable_driver();
605 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
606 CHK_(ptr);
607 } else {
608 goto handle_unusual;
609 }
610 continue;
611 // optional uint32 seqno = 3;
612 case 3:
613 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
614 _Internal::set_has_seqno(&has_bits);
615 _impl_.seqno_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
616 CHK_(ptr);
617 } else {
618 goto handle_unusual;
619 }
620 continue;
621 // optional string timeline = 4;
622 case 4:
623 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
624 auto str = _internal_mutable_timeline();
625 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
626 CHK_(ptr);
627 } else {
628 goto handle_unusual;
629 }
630 continue;
631 default:
632 goto handle_unusual;
633 } // switch
634 handle_unusual:
635 if ((tag == 0) || ((tag & 7) == 4)) {
636 CHK_(ptr);
637 ctx->SetLastTag(tag);
638 goto message_done;
639 }
640 ptr = UnknownFieldParse(
641 tag,
642 _internal_metadata_.mutable_unknown_fields<std::string>(),
643 ptr, ctx);
644 CHK_(ptr != nullptr);
645 } // while
646 message_done:
647 _impl_._has_bits_.Or(has_bits);
648 return ptr;
649 failure:
650 ptr = nullptr;
651 goto message_done;
652 #undef CHK_
653 }
654
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const655 ::uint8_t* DmaFenceEmitFtraceEvent::_InternalSerialize(
656 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
657 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DmaFenceEmitFtraceEvent)
658 ::uint32_t cached_has_bits = 0;
659 (void) cached_has_bits;
660
661 cached_has_bits = _impl_._has_bits_[0];
662 // optional uint32 context = 1;
663 if (cached_has_bits & 0x00000004u) {
664 target = stream->EnsureSpace(target);
665 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_context(), target);
666 }
667
668 // optional string driver = 2;
669 if (cached_has_bits & 0x00000001u) {
670 target = stream->WriteStringMaybeAliased(
671 2, this->_internal_driver(), target);
672 }
673
674 // optional uint32 seqno = 3;
675 if (cached_has_bits & 0x00000008u) {
676 target = stream->EnsureSpace(target);
677 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_seqno(), target);
678 }
679
680 // optional string timeline = 4;
681 if (cached_has_bits & 0x00000002u) {
682 target = stream->WriteStringMaybeAliased(
683 4, this->_internal_timeline(), target);
684 }
685
686 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
687 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
688 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
689 }
690 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DmaFenceEmitFtraceEvent)
691 return target;
692 }
693
ByteSizeLong() const694 size_t DmaFenceEmitFtraceEvent::ByteSizeLong() const {
695 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DmaFenceEmitFtraceEvent)
696 size_t total_size = 0;
697
698 ::uint32_t cached_has_bits = 0;
699 // Prevent compiler warnings about cached_has_bits being unused
700 (void) cached_has_bits;
701
702 cached_has_bits = _impl_._has_bits_[0];
703 if (cached_has_bits & 0x0000000fu) {
704 // optional string driver = 2;
705 if (cached_has_bits & 0x00000001u) {
706 total_size += 1 +
707 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
708 this->_internal_driver());
709 }
710
711 // optional string timeline = 4;
712 if (cached_has_bits & 0x00000002u) {
713 total_size += 1 +
714 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
715 this->_internal_timeline());
716 }
717
718 // optional uint32 context = 1;
719 if (cached_has_bits & 0x00000004u) {
720 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_context());
721 }
722
723 // optional uint32 seqno = 3;
724 if (cached_has_bits & 0x00000008u) {
725 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seqno());
726 }
727
728 }
729 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
730 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
731 }
732 int cached_size = ::_pbi::ToCachedSize(total_size);
733 SetCachedSize(cached_size);
734 return total_size;
735 }
736
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)737 void DmaFenceEmitFtraceEvent::CheckTypeAndMergeFrom(
738 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
739 MergeFrom(*::_pbi::DownCast<const DmaFenceEmitFtraceEvent*>(
740 &from));
741 }
742
MergeFrom(const DmaFenceEmitFtraceEvent & from)743 void DmaFenceEmitFtraceEvent::MergeFrom(const DmaFenceEmitFtraceEvent& from) {
744 DmaFenceEmitFtraceEvent* const _this = this;
745 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DmaFenceEmitFtraceEvent)
746 GOOGLE_DCHECK_NE(&from, _this);
747 ::uint32_t cached_has_bits = 0;
748 (void) cached_has_bits;
749
750 cached_has_bits = from._impl_._has_bits_[0];
751 if (cached_has_bits & 0x0000000fu) {
752 if (cached_has_bits & 0x00000001u) {
753 _this->_internal_set_driver(from._internal_driver());
754 }
755 if (cached_has_bits & 0x00000002u) {
756 _this->_internal_set_timeline(from._internal_timeline());
757 }
758 if (cached_has_bits & 0x00000004u) {
759 _this->_impl_.context_ = from._impl_.context_;
760 }
761 if (cached_has_bits & 0x00000008u) {
762 _this->_impl_.seqno_ = from._impl_.seqno_;
763 }
764 _this->_impl_._has_bits_[0] |= cached_has_bits;
765 }
766 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
767 }
768
CopyFrom(const DmaFenceEmitFtraceEvent & from)769 void DmaFenceEmitFtraceEvent::CopyFrom(const DmaFenceEmitFtraceEvent& from) {
770 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DmaFenceEmitFtraceEvent)
771 if (&from == this) return;
772 Clear();
773 MergeFrom(from);
774 }
775
IsInitialized() const776 bool DmaFenceEmitFtraceEvent::IsInitialized() const {
777 return true;
778 }
779
InternalSwap(DmaFenceEmitFtraceEvent * other)780 void DmaFenceEmitFtraceEvent::InternalSwap(DmaFenceEmitFtraceEvent* other) {
781 using std::swap;
782 auto* lhs_arena = GetArenaForAllocation();
783 auto* rhs_arena = other->GetArenaForAllocation();
784 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
785 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
786 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
787 &_impl_.driver_, lhs_arena,
788 &other->_impl_.driver_, rhs_arena
789 );
790 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
791 &_impl_.timeline_, lhs_arena,
792 &other->_impl_.timeline_, rhs_arena
793 );
794 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
795 PROTOBUF_FIELD_OFFSET(DmaFenceEmitFtraceEvent, _impl_.seqno_)
796 + sizeof(DmaFenceEmitFtraceEvent::_impl_.seqno_) // NOLINT
797 - PROTOBUF_FIELD_OFFSET(DmaFenceEmitFtraceEvent, _impl_.context_)>(
798 reinterpret_cast<char*>(&_impl_.context_),
799 reinterpret_cast<char*>(&other->_impl_.context_));
800 }
801
GetTypeName() const802 std::string DmaFenceEmitFtraceEvent::GetTypeName() const {
803 return "perfetto.protos.DmaFenceEmitFtraceEvent";
804 }
805
806
807 // ===================================================================
808
809 class DmaFenceSignaledFtraceEvent::_Internal {
810 public:
811 using HasBits = decltype(std::declval<DmaFenceSignaledFtraceEvent>()._impl_._has_bits_);
set_has_context(HasBits * has_bits)812 static void set_has_context(HasBits* has_bits) {
813 (*has_bits)[0] |= 4u;
814 }
set_has_driver(HasBits * has_bits)815 static void set_has_driver(HasBits* has_bits) {
816 (*has_bits)[0] |= 1u;
817 }
set_has_seqno(HasBits * has_bits)818 static void set_has_seqno(HasBits* has_bits) {
819 (*has_bits)[0] |= 8u;
820 }
set_has_timeline(HasBits * has_bits)821 static void set_has_timeline(HasBits* has_bits) {
822 (*has_bits)[0] |= 2u;
823 }
824 };
825
DmaFenceSignaledFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)826 DmaFenceSignaledFtraceEvent::DmaFenceSignaledFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
827 bool is_message_owned)
828 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
829 SharedCtor(arena, is_message_owned);
830 // @@protoc_insertion_point(arena_constructor:perfetto.protos.DmaFenceSignaledFtraceEvent)
831 }
DmaFenceSignaledFtraceEvent(const DmaFenceSignaledFtraceEvent & from)832 DmaFenceSignaledFtraceEvent::DmaFenceSignaledFtraceEvent(const DmaFenceSignaledFtraceEvent& from)
833 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
834 DmaFenceSignaledFtraceEvent* const _this = this; (void)_this;
835 new (&_impl_) Impl_{
836 decltype(_impl_._has_bits_){from._impl_._has_bits_}
837 , /*decltype(_impl_._cached_size_)*/{}
838 , decltype(_impl_.driver_){}
839 , decltype(_impl_.timeline_){}
840 , decltype(_impl_.context_){}
841 , decltype(_impl_.seqno_){}};
842
843 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
844 _impl_.driver_.InitDefault();
845 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
846 _impl_.driver_.Set("", GetArenaForAllocation());
847 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
848 if (from._internal_has_driver()) {
849 _this->_impl_.driver_.Set(from._internal_driver(),
850 _this->GetArenaForAllocation());
851 }
852 _impl_.timeline_.InitDefault();
853 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
854 _impl_.timeline_.Set("", GetArenaForAllocation());
855 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
856 if (from._internal_has_timeline()) {
857 _this->_impl_.timeline_.Set(from._internal_timeline(),
858 _this->GetArenaForAllocation());
859 }
860 ::memcpy(&_impl_.context_, &from._impl_.context_,
861 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.seqno_) -
862 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
863 // @@protoc_insertion_point(copy_constructor:perfetto.protos.DmaFenceSignaledFtraceEvent)
864 }
865
SharedCtor(::_pb::Arena * arena,bool is_message_owned)866 inline void DmaFenceSignaledFtraceEvent::SharedCtor(
867 ::_pb::Arena* arena, bool is_message_owned) {
868 (void)arena;
869 (void)is_message_owned;
870 new (&_impl_) Impl_{
871 decltype(_impl_._has_bits_){}
872 , /*decltype(_impl_._cached_size_)*/{}
873 , decltype(_impl_.driver_){}
874 , decltype(_impl_.timeline_){}
875 , decltype(_impl_.context_){0u}
876 , decltype(_impl_.seqno_){0u}
877 };
878 _impl_.driver_.InitDefault();
879 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
880 _impl_.driver_.Set("", GetArenaForAllocation());
881 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
882 _impl_.timeline_.InitDefault();
883 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
884 _impl_.timeline_.Set("", GetArenaForAllocation());
885 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
886 }
887
~DmaFenceSignaledFtraceEvent()888 DmaFenceSignaledFtraceEvent::~DmaFenceSignaledFtraceEvent() {
889 // @@protoc_insertion_point(destructor:perfetto.protos.DmaFenceSignaledFtraceEvent)
890 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
891 (void)arena;
892 return;
893 }
894 SharedDtor();
895 }
896
SharedDtor()897 inline void DmaFenceSignaledFtraceEvent::SharedDtor() {
898 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
899 _impl_.driver_.Destroy();
900 _impl_.timeline_.Destroy();
901 }
902
SetCachedSize(int size) const903 void DmaFenceSignaledFtraceEvent::SetCachedSize(int size) const {
904 _impl_._cached_size_.Set(size);
905 }
906
Clear()907 void DmaFenceSignaledFtraceEvent::Clear() {
908 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DmaFenceSignaledFtraceEvent)
909 ::uint32_t cached_has_bits = 0;
910 // Prevent compiler warnings about cached_has_bits being unused
911 (void) cached_has_bits;
912
913 cached_has_bits = _impl_._has_bits_[0];
914 if (cached_has_bits & 0x00000003u) {
915 if (cached_has_bits & 0x00000001u) {
916 _impl_.driver_.ClearNonDefaultToEmpty();
917 }
918 if (cached_has_bits & 0x00000002u) {
919 _impl_.timeline_.ClearNonDefaultToEmpty();
920 }
921 }
922 if (cached_has_bits & 0x0000000cu) {
923 ::memset(&_impl_.context_, 0, static_cast<size_t>(
924 reinterpret_cast<char*>(&_impl_.seqno_) -
925 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
926 }
927 _impl_._has_bits_.Clear();
928 _internal_metadata_.Clear<std::string>();
929 }
930
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)931 const char* DmaFenceSignaledFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
932 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
933 _Internal::HasBits has_bits{};
934 while (!ctx->Done(&ptr)) {
935 ::uint32_t tag;
936 ptr = ::_pbi::ReadTag(ptr, &tag);
937 switch (tag >> 3) {
938 // optional uint32 context = 1;
939 case 1:
940 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
941 _Internal::set_has_context(&has_bits);
942 _impl_.context_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
943 CHK_(ptr);
944 } else {
945 goto handle_unusual;
946 }
947 continue;
948 // optional string driver = 2;
949 case 2:
950 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
951 auto str = _internal_mutable_driver();
952 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
953 CHK_(ptr);
954 } else {
955 goto handle_unusual;
956 }
957 continue;
958 // optional uint32 seqno = 3;
959 case 3:
960 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
961 _Internal::set_has_seqno(&has_bits);
962 _impl_.seqno_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
963 CHK_(ptr);
964 } else {
965 goto handle_unusual;
966 }
967 continue;
968 // optional string timeline = 4;
969 case 4:
970 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
971 auto str = _internal_mutable_timeline();
972 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
973 CHK_(ptr);
974 } else {
975 goto handle_unusual;
976 }
977 continue;
978 default:
979 goto handle_unusual;
980 } // switch
981 handle_unusual:
982 if ((tag == 0) || ((tag & 7) == 4)) {
983 CHK_(ptr);
984 ctx->SetLastTag(tag);
985 goto message_done;
986 }
987 ptr = UnknownFieldParse(
988 tag,
989 _internal_metadata_.mutable_unknown_fields<std::string>(),
990 ptr, ctx);
991 CHK_(ptr != nullptr);
992 } // while
993 message_done:
994 _impl_._has_bits_.Or(has_bits);
995 return ptr;
996 failure:
997 ptr = nullptr;
998 goto message_done;
999 #undef CHK_
1000 }
1001
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1002 ::uint8_t* DmaFenceSignaledFtraceEvent::_InternalSerialize(
1003 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1004 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DmaFenceSignaledFtraceEvent)
1005 ::uint32_t cached_has_bits = 0;
1006 (void) cached_has_bits;
1007
1008 cached_has_bits = _impl_._has_bits_[0];
1009 // optional uint32 context = 1;
1010 if (cached_has_bits & 0x00000004u) {
1011 target = stream->EnsureSpace(target);
1012 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_context(), target);
1013 }
1014
1015 // optional string driver = 2;
1016 if (cached_has_bits & 0x00000001u) {
1017 target = stream->WriteStringMaybeAliased(
1018 2, this->_internal_driver(), target);
1019 }
1020
1021 // optional uint32 seqno = 3;
1022 if (cached_has_bits & 0x00000008u) {
1023 target = stream->EnsureSpace(target);
1024 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_seqno(), target);
1025 }
1026
1027 // optional string timeline = 4;
1028 if (cached_has_bits & 0x00000002u) {
1029 target = stream->WriteStringMaybeAliased(
1030 4, this->_internal_timeline(), target);
1031 }
1032
1033 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1034 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1035 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1036 }
1037 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DmaFenceSignaledFtraceEvent)
1038 return target;
1039 }
1040
ByteSizeLong() const1041 size_t DmaFenceSignaledFtraceEvent::ByteSizeLong() const {
1042 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DmaFenceSignaledFtraceEvent)
1043 size_t total_size = 0;
1044
1045 ::uint32_t cached_has_bits = 0;
1046 // Prevent compiler warnings about cached_has_bits being unused
1047 (void) cached_has_bits;
1048
1049 cached_has_bits = _impl_._has_bits_[0];
1050 if (cached_has_bits & 0x0000000fu) {
1051 // optional string driver = 2;
1052 if (cached_has_bits & 0x00000001u) {
1053 total_size += 1 +
1054 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1055 this->_internal_driver());
1056 }
1057
1058 // optional string timeline = 4;
1059 if (cached_has_bits & 0x00000002u) {
1060 total_size += 1 +
1061 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1062 this->_internal_timeline());
1063 }
1064
1065 // optional uint32 context = 1;
1066 if (cached_has_bits & 0x00000004u) {
1067 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_context());
1068 }
1069
1070 // optional uint32 seqno = 3;
1071 if (cached_has_bits & 0x00000008u) {
1072 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seqno());
1073 }
1074
1075 }
1076 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1077 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1078 }
1079 int cached_size = ::_pbi::ToCachedSize(total_size);
1080 SetCachedSize(cached_size);
1081 return total_size;
1082 }
1083
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1084 void DmaFenceSignaledFtraceEvent::CheckTypeAndMergeFrom(
1085 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1086 MergeFrom(*::_pbi::DownCast<const DmaFenceSignaledFtraceEvent*>(
1087 &from));
1088 }
1089
MergeFrom(const DmaFenceSignaledFtraceEvent & from)1090 void DmaFenceSignaledFtraceEvent::MergeFrom(const DmaFenceSignaledFtraceEvent& from) {
1091 DmaFenceSignaledFtraceEvent* const _this = this;
1092 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DmaFenceSignaledFtraceEvent)
1093 GOOGLE_DCHECK_NE(&from, _this);
1094 ::uint32_t cached_has_bits = 0;
1095 (void) cached_has_bits;
1096
1097 cached_has_bits = from._impl_._has_bits_[0];
1098 if (cached_has_bits & 0x0000000fu) {
1099 if (cached_has_bits & 0x00000001u) {
1100 _this->_internal_set_driver(from._internal_driver());
1101 }
1102 if (cached_has_bits & 0x00000002u) {
1103 _this->_internal_set_timeline(from._internal_timeline());
1104 }
1105 if (cached_has_bits & 0x00000004u) {
1106 _this->_impl_.context_ = from._impl_.context_;
1107 }
1108 if (cached_has_bits & 0x00000008u) {
1109 _this->_impl_.seqno_ = from._impl_.seqno_;
1110 }
1111 _this->_impl_._has_bits_[0] |= cached_has_bits;
1112 }
1113 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1114 }
1115
CopyFrom(const DmaFenceSignaledFtraceEvent & from)1116 void DmaFenceSignaledFtraceEvent::CopyFrom(const DmaFenceSignaledFtraceEvent& from) {
1117 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DmaFenceSignaledFtraceEvent)
1118 if (&from == this) return;
1119 Clear();
1120 MergeFrom(from);
1121 }
1122
IsInitialized() const1123 bool DmaFenceSignaledFtraceEvent::IsInitialized() const {
1124 return true;
1125 }
1126
InternalSwap(DmaFenceSignaledFtraceEvent * other)1127 void DmaFenceSignaledFtraceEvent::InternalSwap(DmaFenceSignaledFtraceEvent* other) {
1128 using std::swap;
1129 auto* lhs_arena = GetArenaForAllocation();
1130 auto* rhs_arena = other->GetArenaForAllocation();
1131 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1132 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1133 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1134 &_impl_.driver_, lhs_arena,
1135 &other->_impl_.driver_, rhs_arena
1136 );
1137 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1138 &_impl_.timeline_, lhs_arena,
1139 &other->_impl_.timeline_, rhs_arena
1140 );
1141 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1142 PROTOBUF_FIELD_OFFSET(DmaFenceSignaledFtraceEvent, _impl_.seqno_)
1143 + sizeof(DmaFenceSignaledFtraceEvent::_impl_.seqno_) // NOLINT
1144 - PROTOBUF_FIELD_OFFSET(DmaFenceSignaledFtraceEvent, _impl_.context_)>(
1145 reinterpret_cast<char*>(&_impl_.context_),
1146 reinterpret_cast<char*>(&other->_impl_.context_));
1147 }
1148
GetTypeName() const1149 std::string DmaFenceSignaledFtraceEvent::GetTypeName() const {
1150 return "perfetto.protos.DmaFenceSignaledFtraceEvent";
1151 }
1152
1153
1154 // ===================================================================
1155
1156 class DmaFenceWaitStartFtraceEvent::_Internal {
1157 public:
1158 using HasBits = decltype(std::declval<DmaFenceWaitStartFtraceEvent>()._impl_._has_bits_);
set_has_context(HasBits * has_bits)1159 static void set_has_context(HasBits* has_bits) {
1160 (*has_bits)[0] |= 4u;
1161 }
set_has_driver(HasBits * has_bits)1162 static void set_has_driver(HasBits* has_bits) {
1163 (*has_bits)[0] |= 1u;
1164 }
set_has_seqno(HasBits * has_bits)1165 static void set_has_seqno(HasBits* has_bits) {
1166 (*has_bits)[0] |= 8u;
1167 }
set_has_timeline(HasBits * has_bits)1168 static void set_has_timeline(HasBits* has_bits) {
1169 (*has_bits)[0] |= 2u;
1170 }
1171 };
1172
DmaFenceWaitStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1173 DmaFenceWaitStartFtraceEvent::DmaFenceWaitStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1174 bool is_message_owned)
1175 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1176 SharedCtor(arena, is_message_owned);
1177 // @@protoc_insertion_point(arena_constructor:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1178 }
DmaFenceWaitStartFtraceEvent(const DmaFenceWaitStartFtraceEvent & from)1179 DmaFenceWaitStartFtraceEvent::DmaFenceWaitStartFtraceEvent(const DmaFenceWaitStartFtraceEvent& from)
1180 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1181 DmaFenceWaitStartFtraceEvent* const _this = this; (void)_this;
1182 new (&_impl_) Impl_{
1183 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1184 , /*decltype(_impl_._cached_size_)*/{}
1185 , decltype(_impl_.driver_){}
1186 , decltype(_impl_.timeline_){}
1187 , decltype(_impl_.context_){}
1188 , decltype(_impl_.seqno_){}};
1189
1190 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1191 _impl_.driver_.InitDefault();
1192 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1193 _impl_.driver_.Set("", GetArenaForAllocation());
1194 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1195 if (from._internal_has_driver()) {
1196 _this->_impl_.driver_.Set(from._internal_driver(),
1197 _this->GetArenaForAllocation());
1198 }
1199 _impl_.timeline_.InitDefault();
1200 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1201 _impl_.timeline_.Set("", GetArenaForAllocation());
1202 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1203 if (from._internal_has_timeline()) {
1204 _this->_impl_.timeline_.Set(from._internal_timeline(),
1205 _this->GetArenaForAllocation());
1206 }
1207 ::memcpy(&_impl_.context_, &from._impl_.context_,
1208 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.seqno_) -
1209 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
1210 // @@protoc_insertion_point(copy_constructor:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1211 }
1212
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1213 inline void DmaFenceWaitStartFtraceEvent::SharedCtor(
1214 ::_pb::Arena* arena, bool is_message_owned) {
1215 (void)arena;
1216 (void)is_message_owned;
1217 new (&_impl_) Impl_{
1218 decltype(_impl_._has_bits_){}
1219 , /*decltype(_impl_._cached_size_)*/{}
1220 , decltype(_impl_.driver_){}
1221 , decltype(_impl_.timeline_){}
1222 , decltype(_impl_.context_){0u}
1223 , decltype(_impl_.seqno_){0u}
1224 };
1225 _impl_.driver_.InitDefault();
1226 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1227 _impl_.driver_.Set("", GetArenaForAllocation());
1228 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1229 _impl_.timeline_.InitDefault();
1230 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1231 _impl_.timeline_.Set("", GetArenaForAllocation());
1232 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1233 }
1234
~DmaFenceWaitStartFtraceEvent()1235 DmaFenceWaitStartFtraceEvent::~DmaFenceWaitStartFtraceEvent() {
1236 // @@protoc_insertion_point(destructor:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1237 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1238 (void)arena;
1239 return;
1240 }
1241 SharedDtor();
1242 }
1243
SharedDtor()1244 inline void DmaFenceWaitStartFtraceEvent::SharedDtor() {
1245 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1246 _impl_.driver_.Destroy();
1247 _impl_.timeline_.Destroy();
1248 }
1249
SetCachedSize(int size) const1250 void DmaFenceWaitStartFtraceEvent::SetCachedSize(int size) const {
1251 _impl_._cached_size_.Set(size);
1252 }
1253
Clear()1254 void DmaFenceWaitStartFtraceEvent::Clear() {
1255 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1256 ::uint32_t cached_has_bits = 0;
1257 // Prevent compiler warnings about cached_has_bits being unused
1258 (void) cached_has_bits;
1259
1260 cached_has_bits = _impl_._has_bits_[0];
1261 if (cached_has_bits & 0x00000003u) {
1262 if (cached_has_bits & 0x00000001u) {
1263 _impl_.driver_.ClearNonDefaultToEmpty();
1264 }
1265 if (cached_has_bits & 0x00000002u) {
1266 _impl_.timeline_.ClearNonDefaultToEmpty();
1267 }
1268 }
1269 if (cached_has_bits & 0x0000000cu) {
1270 ::memset(&_impl_.context_, 0, static_cast<size_t>(
1271 reinterpret_cast<char*>(&_impl_.seqno_) -
1272 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
1273 }
1274 _impl_._has_bits_.Clear();
1275 _internal_metadata_.Clear<std::string>();
1276 }
1277
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1278 const char* DmaFenceWaitStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1279 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1280 _Internal::HasBits has_bits{};
1281 while (!ctx->Done(&ptr)) {
1282 ::uint32_t tag;
1283 ptr = ::_pbi::ReadTag(ptr, &tag);
1284 switch (tag >> 3) {
1285 // optional uint32 context = 1;
1286 case 1:
1287 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1288 _Internal::set_has_context(&has_bits);
1289 _impl_.context_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1290 CHK_(ptr);
1291 } else {
1292 goto handle_unusual;
1293 }
1294 continue;
1295 // optional string driver = 2;
1296 case 2:
1297 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1298 auto str = _internal_mutable_driver();
1299 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1300 CHK_(ptr);
1301 } else {
1302 goto handle_unusual;
1303 }
1304 continue;
1305 // optional uint32 seqno = 3;
1306 case 3:
1307 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1308 _Internal::set_has_seqno(&has_bits);
1309 _impl_.seqno_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1310 CHK_(ptr);
1311 } else {
1312 goto handle_unusual;
1313 }
1314 continue;
1315 // optional string timeline = 4;
1316 case 4:
1317 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1318 auto str = _internal_mutable_timeline();
1319 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1320 CHK_(ptr);
1321 } else {
1322 goto handle_unusual;
1323 }
1324 continue;
1325 default:
1326 goto handle_unusual;
1327 } // switch
1328 handle_unusual:
1329 if ((tag == 0) || ((tag & 7) == 4)) {
1330 CHK_(ptr);
1331 ctx->SetLastTag(tag);
1332 goto message_done;
1333 }
1334 ptr = UnknownFieldParse(
1335 tag,
1336 _internal_metadata_.mutable_unknown_fields<std::string>(),
1337 ptr, ctx);
1338 CHK_(ptr != nullptr);
1339 } // while
1340 message_done:
1341 _impl_._has_bits_.Or(has_bits);
1342 return ptr;
1343 failure:
1344 ptr = nullptr;
1345 goto message_done;
1346 #undef CHK_
1347 }
1348
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1349 ::uint8_t* DmaFenceWaitStartFtraceEvent::_InternalSerialize(
1350 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1351 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1352 ::uint32_t cached_has_bits = 0;
1353 (void) cached_has_bits;
1354
1355 cached_has_bits = _impl_._has_bits_[0];
1356 // optional uint32 context = 1;
1357 if (cached_has_bits & 0x00000004u) {
1358 target = stream->EnsureSpace(target);
1359 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_context(), target);
1360 }
1361
1362 // optional string driver = 2;
1363 if (cached_has_bits & 0x00000001u) {
1364 target = stream->WriteStringMaybeAliased(
1365 2, this->_internal_driver(), target);
1366 }
1367
1368 // optional uint32 seqno = 3;
1369 if (cached_has_bits & 0x00000008u) {
1370 target = stream->EnsureSpace(target);
1371 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_seqno(), target);
1372 }
1373
1374 // optional string timeline = 4;
1375 if (cached_has_bits & 0x00000002u) {
1376 target = stream->WriteStringMaybeAliased(
1377 4, this->_internal_timeline(), target);
1378 }
1379
1380 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1381 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1382 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1383 }
1384 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1385 return target;
1386 }
1387
ByteSizeLong() const1388 size_t DmaFenceWaitStartFtraceEvent::ByteSizeLong() const {
1389 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1390 size_t total_size = 0;
1391
1392 ::uint32_t cached_has_bits = 0;
1393 // Prevent compiler warnings about cached_has_bits being unused
1394 (void) cached_has_bits;
1395
1396 cached_has_bits = _impl_._has_bits_[0];
1397 if (cached_has_bits & 0x0000000fu) {
1398 // optional string driver = 2;
1399 if (cached_has_bits & 0x00000001u) {
1400 total_size += 1 +
1401 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1402 this->_internal_driver());
1403 }
1404
1405 // optional string timeline = 4;
1406 if (cached_has_bits & 0x00000002u) {
1407 total_size += 1 +
1408 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1409 this->_internal_timeline());
1410 }
1411
1412 // optional uint32 context = 1;
1413 if (cached_has_bits & 0x00000004u) {
1414 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_context());
1415 }
1416
1417 // optional uint32 seqno = 3;
1418 if (cached_has_bits & 0x00000008u) {
1419 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seqno());
1420 }
1421
1422 }
1423 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1424 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1425 }
1426 int cached_size = ::_pbi::ToCachedSize(total_size);
1427 SetCachedSize(cached_size);
1428 return total_size;
1429 }
1430
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1431 void DmaFenceWaitStartFtraceEvent::CheckTypeAndMergeFrom(
1432 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1433 MergeFrom(*::_pbi::DownCast<const DmaFenceWaitStartFtraceEvent*>(
1434 &from));
1435 }
1436
MergeFrom(const DmaFenceWaitStartFtraceEvent & from)1437 void DmaFenceWaitStartFtraceEvent::MergeFrom(const DmaFenceWaitStartFtraceEvent& from) {
1438 DmaFenceWaitStartFtraceEvent* const _this = this;
1439 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1440 GOOGLE_DCHECK_NE(&from, _this);
1441 ::uint32_t cached_has_bits = 0;
1442 (void) cached_has_bits;
1443
1444 cached_has_bits = from._impl_._has_bits_[0];
1445 if (cached_has_bits & 0x0000000fu) {
1446 if (cached_has_bits & 0x00000001u) {
1447 _this->_internal_set_driver(from._internal_driver());
1448 }
1449 if (cached_has_bits & 0x00000002u) {
1450 _this->_internal_set_timeline(from._internal_timeline());
1451 }
1452 if (cached_has_bits & 0x00000004u) {
1453 _this->_impl_.context_ = from._impl_.context_;
1454 }
1455 if (cached_has_bits & 0x00000008u) {
1456 _this->_impl_.seqno_ = from._impl_.seqno_;
1457 }
1458 _this->_impl_._has_bits_[0] |= cached_has_bits;
1459 }
1460 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1461 }
1462
CopyFrom(const DmaFenceWaitStartFtraceEvent & from)1463 void DmaFenceWaitStartFtraceEvent::CopyFrom(const DmaFenceWaitStartFtraceEvent& from) {
1464 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DmaFenceWaitStartFtraceEvent)
1465 if (&from == this) return;
1466 Clear();
1467 MergeFrom(from);
1468 }
1469
IsInitialized() const1470 bool DmaFenceWaitStartFtraceEvent::IsInitialized() const {
1471 return true;
1472 }
1473
InternalSwap(DmaFenceWaitStartFtraceEvent * other)1474 void DmaFenceWaitStartFtraceEvent::InternalSwap(DmaFenceWaitStartFtraceEvent* other) {
1475 using std::swap;
1476 auto* lhs_arena = GetArenaForAllocation();
1477 auto* rhs_arena = other->GetArenaForAllocation();
1478 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1479 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1480 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1481 &_impl_.driver_, lhs_arena,
1482 &other->_impl_.driver_, rhs_arena
1483 );
1484 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1485 &_impl_.timeline_, lhs_arena,
1486 &other->_impl_.timeline_, rhs_arena
1487 );
1488 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1489 PROTOBUF_FIELD_OFFSET(DmaFenceWaitStartFtraceEvent, _impl_.seqno_)
1490 + sizeof(DmaFenceWaitStartFtraceEvent::_impl_.seqno_) // NOLINT
1491 - PROTOBUF_FIELD_OFFSET(DmaFenceWaitStartFtraceEvent, _impl_.context_)>(
1492 reinterpret_cast<char*>(&_impl_.context_),
1493 reinterpret_cast<char*>(&other->_impl_.context_));
1494 }
1495
GetTypeName() const1496 std::string DmaFenceWaitStartFtraceEvent::GetTypeName() const {
1497 return "perfetto.protos.DmaFenceWaitStartFtraceEvent";
1498 }
1499
1500
1501 // ===================================================================
1502
1503 class DmaFenceWaitEndFtraceEvent::_Internal {
1504 public:
1505 using HasBits = decltype(std::declval<DmaFenceWaitEndFtraceEvent>()._impl_._has_bits_);
set_has_context(HasBits * has_bits)1506 static void set_has_context(HasBits* has_bits) {
1507 (*has_bits)[0] |= 4u;
1508 }
set_has_driver(HasBits * has_bits)1509 static void set_has_driver(HasBits* has_bits) {
1510 (*has_bits)[0] |= 1u;
1511 }
set_has_seqno(HasBits * has_bits)1512 static void set_has_seqno(HasBits* has_bits) {
1513 (*has_bits)[0] |= 8u;
1514 }
set_has_timeline(HasBits * has_bits)1515 static void set_has_timeline(HasBits* has_bits) {
1516 (*has_bits)[0] |= 2u;
1517 }
1518 };
1519
DmaFenceWaitEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1520 DmaFenceWaitEndFtraceEvent::DmaFenceWaitEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1521 bool is_message_owned)
1522 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1523 SharedCtor(arena, is_message_owned);
1524 // @@protoc_insertion_point(arena_constructor:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1525 }
DmaFenceWaitEndFtraceEvent(const DmaFenceWaitEndFtraceEvent & from)1526 DmaFenceWaitEndFtraceEvent::DmaFenceWaitEndFtraceEvent(const DmaFenceWaitEndFtraceEvent& from)
1527 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1528 DmaFenceWaitEndFtraceEvent* const _this = this; (void)_this;
1529 new (&_impl_) Impl_{
1530 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1531 , /*decltype(_impl_._cached_size_)*/{}
1532 , decltype(_impl_.driver_){}
1533 , decltype(_impl_.timeline_){}
1534 , decltype(_impl_.context_){}
1535 , decltype(_impl_.seqno_){}};
1536
1537 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1538 _impl_.driver_.InitDefault();
1539 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1540 _impl_.driver_.Set("", GetArenaForAllocation());
1541 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1542 if (from._internal_has_driver()) {
1543 _this->_impl_.driver_.Set(from._internal_driver(),
1544 _this->GetArenaForAllocation());
1545 }
1546 _impl_.timeline_.InitDefault();
1547 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1548 _impl_.timeline_.Set("", GetArenaForAllocation());
1549 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1550 if (from._internal_has_timeline()) {
1551 _this->_impl_.timeline_.Set(from._internal_timeline(),
1552 _this->GetArenaForAllocation());
1553 }
1554 ::memcpy(&_impl_.context_, &from._impl_.context_,
1555 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.seqno_) -
1556 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
1557 // @@protoc_insertion_point(copy_constructor:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1558 }
1559
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1560 inline void DmaFenceWaitEndFtraceEvent::SharedCtor(
1561 ::_pb::Arena* arena, bool is_message_owned) {
1562 (void)arena;
1563 (void)is_message_owned;
1564 new (&_impl_) Impl_{
1565 decltype(_impl_._has_bits_){}
1566 , /*decltype(_impl_._cached_size_)*/{}
1567 , decltype(_impl_.driver_){}
1568 , decltype(_impl_.timeline_){}
1569 , decltype(_impl_.context_){0u}
1570 , decltype(_impl_.seqno_){0u}
1571 };
1572 _impl_.driver_.InitDefault();
1573 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1574 _impl_.driver_.Set("", GetArenaForAllocation());
1575 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1576 _impl_.timeline_.InitDefault();
1577 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1578 _impl_.timeline_.Set("", GetArenaForAllocation());
1579 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1580 }
1581
~DmaFenceWaitEndFtraceEvent()1582 DmaFenceWaitEndFtraceEvent::~DmaFenceWaitEndFtraceEvent() {
1583 // @@protoc_insertion_point(destructor:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1584 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1585 (void)arena;
1586 return;
1587 }
1588 SharedDtor();
1589 }
1590
SharedDtor()1591 inline void DmaFenceWaitEndFtraceEvent::SharedDtor() {
1592 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1593 _impl_.driver_.Destroy();
1594 _impl_.timeline_.Destroy();
1595 }
1596
SetCachedSize(int size) const1597 void DmaFenceWaitEndFtraceEvent::SetCachedSize(int size) const {
1598 _impl_._cached_size_.Set(size);
1599 }
1600
Clear()1601 void DmaFenceWaitEndFtraceEvent::Clear() {
1602 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1603 ::uint32_t cached_has_bits = 0;
1604 // Prevent compiler warnings about cached_has_bits being unused
1605 (void) cached_has_bits;
1606
1607 cached_has_bits = _impl_._has_bits_[0];
1608 if (cached_has_bits & 0x00000003u) {
1609 if (cached_has_bits & 0x00000001u) {
1610 _impl_.driver_.ClearNonDefaultToEmpty();
1611 }
1612 if (cached_has_bits & 0x00000002u) {
1613 _impl_.timeline_.ClearNonDefaultToEmpty();
1614 }
1615 }
1616 if (cached_has_bits & 0x0000000cu) {
1617 ::memset(&_impl_.context_, 0, static_cast<size_t>(
1618 reinterpret_cast<char*>(&_impl_.seqno_) -
1619 reinterpret_cast<char*>(&_impl_.context_)) + sizeof(_impl_.seqno_));
1620 }
1621 _impl_._has_bits_.Clear();
1622 _internal_metadata_.Clear<std::string>();
1623 }
1624
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1625 const char* DmaFenceWaitEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1626 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1627 _Internal::HasBits has_bits{};
1628 while (!ctx->Done(&ptr)) {
1629 ::uint32_t tag;
1630 ptr = ::_pbi::ReadTag(ptr, &tag);
1631 switch (tag >> 3) {
1632 // optional uint32 context = 1;
1633 case 1:
1634 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1635 _Internal::set_has_context(&has_bits);
1636 _impl_.context_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1637 CHK_(ptr);
1638 } else {
1639 goto handle_unusual;
1640 }
1641 continue;
1642 // optional string driver = 2;
1643 case 2:
1644 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1645 auto str = _internal_mutable_driver();
1646 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1647 CHK_(ptr);
1648 } else {
1649 goto handle_unusual;
1650 }
1651 continue;
1652 // optional uint32 seqno = 3;
1653 case 3:
1654 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1655 _Internal::set_has_seqno(&has_bits);
1656 _impl_.seqno_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1657 CHK_(ptr);
1658 } else {
1659 goto handle_unusual;
1660 }
1661 continue;
1662 // optional string timeline = 4;
1663 case 4:
1664 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1665 auto str = _internal_mutable_timeline();
1666 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1667 CHK_(ptr);
1668 } else {
1669 goto handle_unusual;
1670 }
1671 continue;
1672 default:
1673 goto handle_unusual;
1674 } // switch
1675 handle_unusual:
1676 if ((tag == 0) || ((tag & 7) == 4)) {
1677 CHK_(ptr);
1678 ctx->SetLastTag(tag);
1679 goto message_done;
1680 }
1681 ptr = UnknownFieldParse(
1682 tag,
1683 _internal_metadata_.mutable_unknown_fields<std::string>(),
1684 ptr, ctx);
1685 CHK_(ptr != nullptr);
1686 } // while
1687 message_done:
1688 _impl_._has_bits_.Or(has_bits);
1689 return ptr;
1690 failure:
1691 ptr = nullptr;
1692 goto message_done;
1693 #undef CHK_
1694 }
1695
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1696 ::uint8_t* DmaFenceWaitEndFtraceEvent::_InternalSerialize(
1697 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1698 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1699 ::uint32_t cached_has_bits = 0;
1700 (void) cached_has_bits;
1701
1702 cached_has_bits = _impl_._has_bits_[0];
1703 // optional uint32 context = 1;
1704 if (cached_has_bits & 0x00000004u) {
1705 target = stream->EnsureSpace(target);
1706 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_context(), target);
1707 }
1708
1709 // optional string driver = 2;
1710 if (cached_has_bits & 0x00000001u) {
1711 target = stream->WriteStringMaybeAliased(
1712 2, this->_internal_driver(), target);
1713 }
1714
1715 // optional uint32 seqno = 3;
1716 if (cached_has_bits & 0x00000008u) {
1717 target = stream->EnsureSpace(target);
1718 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_seqno(), target);
1719 }
1720
1721 // optional string timeline = 4;
1722 if (cached_has_bits & 0x00000002u) {
1723 target = stream->WriteStringMaybeAliased(
1724 4, this->_internal_timeline(), target);
1725 }
1726
1727 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1728 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1729 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1730 }
1731 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1732 return target;
1733 }
1734
ByteSizeLong() const1735 size_t DmaFenceWaitEndFtraceEvent::ByteSizeLong() const {
1736 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1737 size_t total_size = 0;
1738
1739 ::uint32_t cached_has_bits = 0;
1740 // Prevent compiler warnings about cached_has_bits being unused
1741 (void) cached_has_bits;
1742
1743 cached_has_bits = _impl_._has_bits_[0];
1744 if (cached_has_bits & 0x0000000fu) {
1745 // optional string driver = 2;
1746 if (cached_has_bits & 0x00000001u) {
1747 total_size += 1 +
1748 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1749 this->_internal_driver());
1750 }
1751
1752 // optional string timeline = 4;
1753 if (cached_has_bits & 0x00000002u) {
1754 total_size += 1 +
1755 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1756 this->_internal_timeline());
1757 }
1758
1759 // optional uint32 context = 1;
1760 if (cached_has_bits & 0x00000004u) {
1761 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_context());
1762 }
1763
1764 // optional uint32 seqno = 3;
1765 if (cached_has_bits & 0x00000008u) {
1766 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seqno());
1767 }
1768
1769 }
1770 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1771 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1772 }
1773 int cached_size = ::_pbi::ToCachedSize(total_size);
1774 SetCachedSize(cached_size);
1775 return total_size;
1776 }
1777
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1778 void DmaFenceWaitEndFtraceEvent::CheckTypeAndMergeFrom(
1779 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1780 MergeFrom(*::_pbi::DownCast<const DmaFenceWaitEndFtraceEvent*>(
1781 &from));
1782 }
1783
MergeFrom(const DmaFenceWaitEndFtraceEvent & from)1784 void DmaFenceWaitEndFtraceEvent::MergeFrom(const DmaFenceWaitEndFtraceEvent& from) {
1785 DmaFenceWaitEndFtraceEvent* const _this = this;
1786 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1787 GOOGLE_DCHECK_NE(&from, _this);
1788 ::uint32_t cached_has_bits = 0;
1789 (void) cached_has_bits;
1790
1791 cached_has_bits = from._impl_._has_bits_[0];
1792 if (cached_has_bits & 0x0000000fu) {
1793 if (cached_has_bits & 0x00000001u) {
1794 _this->_internal_set_driver(from._internal_driver());
1795 }
1796 if (cached_has_bits & 0x00000002u) {
1797 _this->_internal_set_timeline(from._internal_timeline());
1798 }
1799 if (cached_has_bits & 0x00000004u) {
1800 _this->_impl_.context_ = from._impl_.context_;
1801 }
1802 if (cached_has_bits & 0x00000008u) {
1803 _this->_impl_.seqno_ = from._impl_.seqno_;
1804 }
1805 _this->_impl_._has_bits_[0] |= cached_has_bits;
1806 }
1807 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1808 }
1809
CopyFrom(const DmaFenceWaitEndFtraceEvent & from)1810 void DmaFenceWaitEndFtraceEvent::CopyFrom(const DmaFenceWaitEndFtraceEvent& from) {
1811 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DmaFenceWaitEndFtraceEvent)
1812 if (&from == this) return;
1813 Clear();
1814 MergeFrom(from);
1815 }
1816
IsInitialized() const1817 bool DmaFenceWaitEndFtraceEvent::IsInitialized() const {
1818 return true;
1819 }
1820
InternalSwap(DmaFenceWaitEndFtraceEvent * other)1821 void DmaFenceWaitEndFtraceEvent::InternalSwap(DmaFenceWaitEndFtraceEvent* other) {
1822 using std::swap;
1823 auto* lhs_arena = GetArenaForAllocation();
1824 auto* rhs_arena = other->GetArenaForAllocation();
1825 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1826 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1827 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1828 &_impl_.driver_, lhs_arena,
1829 &other->_impl_.driver_, rhs_arena
1830 );
1831 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1832 &_impl_.timeline_, lhs_arena,
1833 &other->_impl_.timeline_, rhs_arena
1834 );
1835 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1836 PROTOBUF_FIELD_OFFSET(DmaFenceWaitEndFtraceEvent, _impl_.seqno_)
1837 + sizeof(DmaFenceWaitEndFtraceEvent::_impl_.seqno_) // NOLINT
1838 - PROTOBUF_FIELD_OFFSET(DmaFenceWaitEndFtraceEvent, _impl_.context_)>(
1839 reinterpret_cast<char*>(&_impl_.context_),
1840 reinterpret_cast<char*>(&other->_impl_.context_));
1841 }
1842
GetTypeName() const1843 std::string DmaFenceWaitEndFtraceEvent::GetTypeName() const {
1844 return "perfetto.protos.DmaFenceWaitEndFtraceEvent";
1845 }
1846
1847
1848 // @@protoc_insertion_point(namespace_scope)
1849 } // namespace protos
1850 } // namespace perfetto
1851 PROTOBUF_NAMESPACE_OPEN
1852 template<> PROTOBUF_NOINLINE ::perfetto::protos::DmaFenceInitFtraceEvent*
CreateMaybeMessage(Arena * arena)1853 Arena::CreateMaybeMessage< ::perfetto::protos::DmaFenceInitFtraceEvent >(Arena* arena) {
1854 return Arena::CreateMessageInternal< ::perfetto::protos::DmaFenceInitFtraceEvent >(arena);
1855 }
1856 template<> PROTOBUF_NOINLINE ::perfetto::protos::DmaFenceEmitFtraceEvent*
CreateMaybeMessage(Arena * arena)1857 Arena::CreateMaybeMessage< ::perfetto::protos::DmaFenceEmitFtraceEvent >(Arena* arena) {
1858 return Arena::CreateMessageInternal< ::perfetto::protos::DmaFenceEmitFtraceEvent >(arena);
1859 }
1860 template<> PROTOBUF_NOINLINE ::perfetto::protos::DmaFenceSignaledFtraceEvent*
CreateMaybeMessage(Arena * arena)1861 Arena::CreateMaybeMessage< ::perfetto::protos::DmaFenceSignaledFtraceEvent >(Arena* arena) {
1862 return Arena::CreateMessageInternal< ::perfetto::protos::DmaFenceSignaledFtraceEvent >(arena);
1863 }
1864 template<> PROTOBUF_NOINLINE ::perfetto::protos::DmaFenceWaitStartFtraceEvent*
CreateMaybeMessage(Arena * arena)1865 Arena::CreateMaybeMessage< ::perfetto::protos::DmaFenceWaitStartFtraceEvent >(Arena* arena) {
1866 return Arena::CreateMessageInternal< ::perfetto::protos::DmaFenceWaitStartFtraceEvent >(arena);
1867 }
1868 template<> PROTOBUF_NOINLINE ::perfetto::protos::DmaFenceWaitEndFtraceEvent*
CreateMaybeMessage(Arena * arena)1869 Arena::CreateMaybeMessage< ::perfetto::protos::DmaFenceWaitEndFtraceEvent >(Arena* arena) {
1870 return Arena::CreateMessageInternal< ::perfetto::protos::DmaFenceWaitEndFtraceEvent >(arena);
1871 }
1872 PROTOBUF_NAMESPACE_CLOSE
1873
1874 // @@protoc_insertion_point(global_scope)
1875 #include <google/protobuf/port_undef.inc>
1876