1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/dpu.proto
3 
4 #include "protos/perfetto/trace/ftrace/dpu.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 {
DpuTracingMarkWriteFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR DpuTracingMarkWriteFtraceEvent::DpuTracingMarkWriteFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.trace_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.pid_)*/0
30   , /*decltype(_impl_.trace_begin_)*/0u
31   , /*decltype(_impl_.type_)*/0u
32   , /*decltype(_impl_.value_)*/0} {}
33 struct DpuTracingMarkWriteFtraceEventDefaultTypeInternal {
DpuTracingMarkWriteFtraceEventDefaultTypeInternalperfetto::protos::DpuTracingMarkWriteFtraceEventDefaultTypeInternal34   PROTOBUF_CONSTEXPR DpuTracingMarkWriteFtraceEventDefaultTypeInternal()
35       : _instance(::_pbi::ConstantInitialized{}) {}
~DpuTracingMarkWriteFtraceEventDefaultTypeInternalperfetto::protos::DpuTracingMarkWriteFtraceEventDefaultTypeInternal36   ~DpuTracingMarkWriteFtraceEventDefaultTypeInternal() {}
37   union {  // NOLINT(misc-non-private-member-variables-in-classes)
38     DpuTracingMarkWriteFtraceEvent _instance;
39   };
40 };
41 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DpuTracingMarkWriteFtraceEventDefaultTypeInternal _DpuTracingMarkWriteFtraceEvent_default_instance_;
DpuDsiCmdFifoStatusFtraceEvent(::_pbi::ConstantInitialized)42 PROTOBUF_CONSTEXPR DpuDsiCmdFifoStatusFtraceEvent::DpuDsiCmdFifoStatusFtraceEvent(
43     ::_pbi::ConstantInitialized): _impl_{
44     /*decltype(_impl_._has_bits_)*/{}
45   , /*decltype(_impl_._cached_size_)*/{}
46   , /*decltype(_impl_.header_)*/0u
47   , /*decltype(_impl_.payload_)*/0u} {}
48 struct DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternal {
DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternalperfetto::protos::DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternal49   PROTOBUF_CONSTEXPR DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternal()
50       : _instance(::_pbi::ConstantInitialized{}) {}
~DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternalperfetto::protos::DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternal51   ~DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternal() {}
52   union {  // NOLINT(misc-non-private-member-variables-in-classes)
53     DpuDsiCmdFifoStatusFtraceEvent _instance;
54   };
55 };
56 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DpuDsiCmdFifoStatusFtraceEventDefaultTypeInternal _DpuDsiCmdFifoStatusFtraceEvent_default_instance_;
DpuDsiRxFtraceEvent(::_pbi::ConstantInitialized)57 PROTOBUF_CONSTEXPR DpuDsiRxFtraceEvent::DpuDsiRxFtraceEvent(
58     ::_pbi::ConstantInitialized): _impl_{
59     /*decltype(_impl_._has_bits_)*/{}
60   , /*decltype(_impl_._cached_size_)*/{}
61   , /*decltype(_impl_.cmd_)*/0u
62   , /*decltype(_impl_.rx_buf_)*/0u} {}
63 struct DpuDsiRxFtraceEventDefaultTypeInternal {
DpuDsiRxFtraceEventDefaultTypeInternalperfetto::protos::DpuDsiRxFtraceEventDefaultTypeInternal64   PROTOBUF_CONSTEXPR DpuDsiRxFtraceEventDefaultTypeInternal()
65       : _instance(::_pbi::ConstantInitialized{}) {}
~DpuDsiRxFtraceEventDefaultTypeInternalperfetto::protos::DpuDsiRxFtraceEventDefaultTypeInternal66   ~DpuDsiRxFtraceEventDefaultTypeInternal() {}
67   union {  // NOLINT(misc-non-private-member-variables-in-classes)
68     DpuDsiRxFtraceEvent _instance;
69   };
70 };
71 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DpuDsiRxFtraceEventDefaultTypeInternal _DpuDsiRxFtraceEvent_default_instance_;
DpuDsiTxFtraceEvent(::_pbi::ConstantInitialized)72 PROTOBUF_CONSTEXPR DpuDsiTxFtraceEvent::DpuDsiTxFtraceEvent(
73     ::_pbi::ConstantInitialized): _impl_{
74     /*decltype(_impl_._has_bits_)*/{}
75   , /*decltype(_impl_._cached_size_)*/{}
76   , /*decltype(_impl_.type_)*/0u
77   , /*decltype(_impl_.tx_buf_)*/0u
78   , /*decltype(_impl_.last_)*/0u
79   , /*decltype(_impl_.delay_ms_)*/0u} {}
80 struct DpuDsiTxFtraceEventDefaultTypeInternal {
DpuDsiTxFtraceEventDefaultTypeInternalperfetto::protos::DpuDsiTxFtraceEventDefaultTypeInternal81   PROTOBUF_CONSTEXPR DpuDsiTxFtraceEventDefaultTypeInternal()
82       : _instance(::_pbi::ConstantInitialized{}) {}
~DpuDsiTxFtraceEventDefaultTypeInternalperfetto::protos::DpuDsiTxFtraceEventDefaultTypeInternal83   ~DpuDsiTxFtraceEventDefaultTypeInternal() {}
84   union {  // NOLINT(misc-non-private-member-variables-in-classes)
85     DpuDsiTxFtraceEvent _instance;
86   };
87 };
88 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DpuDsiTxFtraceEventDefaultTypeInternal _DpuDsiTxFtraceEvent_default_instance_;
89 }  // namespace protos
90 }  // namespace perfetto
91 namespace perfetto {
92 namespace protos {
93 
94 // ===================================================================
95 
96 class DpuTracingMarkWriteFtraceEvent::_Internal {
97  public:
98   using HasBits = decltype(std::declval<DpuTracingMarkWriteFtraceEvent>()._impl_._has_bits_);
set_has_pid(HasBits * has_bits)99   static void set_has_pid(HasBits* has_bits) {
100     (*has_bits)[0] |= 4u;
101   }
set_has_trace_name(HasBits * has_bits)102   static void set_has_trace_name(HasBits* has_bits) {
103     (*has_bits)[0] |= 1u;
104   }
set_has_trace_begin(HasBits * has_bits)105   static void set_has_trace_begin(HasBits* has_bits) {
106     (*has_bits)[0] |= 8u;
107   }
set_has_name(HasBits * has_bits)108   static void set_has_name(HasBits* has_bits) {
109     (*has_bits)[0] |= 2u;
110   }
set_has_type(HasBits * has_bits)111   static void set_has_type(HasBits* has_bits) {
112     (*has_bits)[0] |= 16u;
113   }
set_has_value(HasBits * has_bits)114   static void set_has_value(HasBits* has_bits) {
115     (*has_bits)[0] |= 32u;
116   }
117 };
118 
DpuTracingMarkWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)119 DpuTracingMarkWriteFtraceEvent::DpuTracingMarkWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
120                          bool is_message_owned)
121   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
122   SharedCtor(arena, is_message_owned);
123   // @@protoc_insertion_point(arena_constructor:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
124 }
DpuTracingMarkWriteFtraceEvent(const DpuTracingMarkWriteFtraceEvent & from)125 DpuTracingMarkWriteFtraceEvent::DpuTracingMarkWriteFtraceEvent(const DpuTracingMarkWriteFtraceEvent& from)
126   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
127   DpuTracingMarkWriteFtraceEvent* const _this = this; (void)_this;
128   new (&_impl_) Impl_{
129       decltype(_impl_._has_bits_){from._impl_._has_bits_}
130     , /*decltype(_impl_._cached_size_)*/{}
131     , decltype(_impl_.trace_name_){}
132     , decltype(_impl_.name_){}
133     , decltype(_impl_.pid_){}
134     , decltype(_impl_.trace_begin_){}
135     , decltype(_impl_.type_){}
136     , decltype(_impl_.value_){}};
137 
138   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
139   _impl_.trace_name_.InitDefault();
140   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
141     _impl_.trace_name_.Set("", GetArenaForAllocation());
142   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
143   if (from._internal_has_trace_name()) {
144     _this->_impl_.trace_name_.Set(from._internal_trace_name(),
145       _this->GetArenaForAllocation());
146   }
147   _impl_.name_.InitDefault();
148   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
149     _impl_.name_.Set("", GetArenaForAllocation());
150   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
151   if (from._internal_has_name()) {
152     _this->_impl_.name_.Set(from._internal_name(),
153       _this->GetArenaForAllocation());
154   }
155   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
156     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.value_) -
157     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.value_));
158   // @@protoc_insertion_point(copy_constructor:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
159 }
160 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)161 inline void DpuTracingMarkWriteFtraceEvent::SharedCtor(
162     ::_pb::Arena* arena, bool is_message_owned) {
163   (void)arena;
164   (void)is_message_owned;
165   new (&_impl_) Impl_{
166       decltype(_impl_._has_bits_){}
167     , /*decltype(_impl_._cached_size_)*/{}
168     , decltype(_impl_.trace_name_){}
169     , decltype(_impl_.name_){}
170     , decltype(_impl_.pid_){0}
171     , decltype(_impl_.trace_begin_){0u}
172     , decltype(_impl_.type_){0u}
173     , decltype(_impl_.value_){0}
174   };
175   _impl_.trace_name_.InitDefault();
176   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
177     _impl_.trace_name_.Set("", GetArenaForAllocation());
178   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
179   _impl_.name_.InitDefault();
180   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
181     _impl_.name_.Set("", GetArenaForAllocation());
182   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
183 }
184 
~DpuTracingMarkWriteFtraceEvent()185 DpuTracingMarkWriteFtraceEvent::~DpuTracingMarkWriteFtraceEvent() {
186   // @@protoc_insertion_point(destructor:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
187   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
188   (void)arena;
189     return;
190   }
191   SharedDtor();
192 }
193 
SharedDtor()194 inline void DpuTracingMarkWriteFtraceEvent::SharedDtor() {
195   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
196   _impl_.trace_name_.Destroy();
197   _impl_.name_.Destroy();
198 }
199 
SetCachedSize(int size) const200 void DpuTracingMarkWriteFtraceEvent::SetCachedSize(int size) const {
201   _impl_._cached_size_.Set(size);
202 }
203 
Clear()204 void DpuTracingMarkWriteFtraceEvent::Clear() {
205 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
206   ::uint32_t cached_has_bits = 0;
207   // Prevent compiler warnings about cached_has_bits being unused
208   (void) cached_has_bits;
209 
210   cached_has_bits = _impl_._has_bits_[0];
211   if (cached_has_bits & 0x00000003u) {
212     if (cached_has_bits & 0x00000001u) {
213       _impl_.trace_name_.ClearNonDefaultToEmpty();
214     }
215     if (cached_has_bits & 0x00000002u) {
216       _impl_.name_.ClearNonDefaultToEmpty();
217     }
218   }
219   if (cached_has_bits & 0x0000003cu) {
220     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
221         reinterpret_cast<char*>(&_impl_.value_) -
222         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.value_));
223   }
224   _impl_._has_bits_.Clear();
225   _internal_metadata_.Clear<std::string>();
226 }
227 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)228 const char* DpuTracingMarkWriteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
229 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
230   _Internal::HasBits has_bits{};
231   while (!ctx->Done(&ptr)) {
232     ::uint32_t tag;
233     ptr = ::_pbi::ReadTag(ptr, &tag);
234     switch (tag >> 3) {
235       // optional int32 pid = 1;
236       case 1:
237         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
238           _Internal::set_has_pid(&has_bits);
239           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
240           CHK_(ptr);
241         } else {
242           goto handle_unusual;
243         }
244         continue;
245       // optional string trace_name = 2;
246       case 2:
247         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
248           auto str = _internal_mutable_trace_name();
249           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
250           CHK_(ptr);
251         } else {
252           goto handle_unusual;
253         }
254         continue;
255       // optional uint32 trace_begin = 3;
256       case 3:
257         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
258           _Internal::set_has_trace_begin(&has_bits);
259           _impl_.trace_begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
260           CHK_(ptr);
261         } else {
262           goto handle_unusual;
263         }
264         continue;
265       // optional string name = 4;
266       case 4:
267         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
268           auto str = _internal_mutable_name();
269           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
270           CHK_(ptr);
271         } else {
272           goto handle_unusual;
273         }
274         continue;
275       // optional uint32 type = 5;
276       case 5:
277         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
278           _Internal::set_has_type(&has_bits);
279           _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
280           CHK_(ptr);
281         } else {
282           goto handle_unusual;
283         }
284         continue;
285       // optional int32 value = 6;
286       case 6:
287         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
288           _Internal::set_has_value(&has_bits);
289           _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
290           CHK_(ptr);
291         } else {
292           goto handle_unusual;
293         }
294         continue;
295       default:
296         goto handle_unusual;
297     }  // switch
298   handle_unusual:
299     if ((tag == 0) || ((tag & 7) == 4)) {
300       CHK_(ptr);
301       ctx->SetLastTag(tag);
302       goto message_done;
303     }
304     ptr = UnknownFieldParse(
305         tag,
306         _internal_metadata_.mutable_unknown_fields<std::string>(),
307         ptr, ctx);
308     CHK_(ptr != nullptr);
309   }  // while
310 message_done:
311   _impl_._has_bits_.Or(has_bits);
312   return ptr;
313 failure:
314   ptr = nullptr;
315   goto message_done;
316 #undef CHK_
317 }
318 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const319 ::uint8_t* DpuTracingMarkWriteFtraceEvent::_InternalSerialize(
320     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
321   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
322   ::uint32_t cached_has_bits = 0;
323   (void) cached_has_bits;
324 
325   cached_has_bits = _impl_._has_bits_[0];
326   // optional int32 pid = 1;
327   if (cached_has_bits & 0x00000004u) {
328     target = stream->EnsureSpace(target);
329     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_pid(), target);
330   }
331 
332   // optional string trace_name = 2;
333   if (cached_has_bits & 0x00000001u) {
334     target = stream->WriteStringMaybeAliased(
335         2, this->_internal_trace_name(), target);
336   }
337 
338   // optional uint32 trace_begin = 3;
339   if (cached_has_bits & 0x00000008u) {
340     target = stream->EnsureSpace(target);
341     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_trace_begin(), target);
342   }
343 
344   // optional string name = 4;
345   if (cached_has_bits & 0x00000002u) {
346     target = stream->WriteStringMaybeAliased(
347         4, this->_internal_name(), target);
348   }
349 
350   // optional uint32 type = 5;
351   if (cached_has_bits & 0x00000010u) {
352     target = stream->EnsureSpace(target);
353     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_type(), target);
354   }
355 
356   // optional int32 value = 6;
357   if (cached_has_bits & 0x00000020u) {
358     target = stream->EnsureSpace(target);
359     target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_value(), target);
360   }
361 
362   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
363     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
364         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
365   }
366   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
367   return target;
368 }
369 
ByteSizeLong() const370 size_t DpuTracingMarkWriteFtraceEvent::ByteSizeLong() const {
371 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
372   size_t total_size = 0;
373 
374   ::uint32_t cached_has_bits = 0;
375   // Prevent compiler warnings about cached_has_bits being unused
376   (void) cached_has_bits;
377 
378   cached_has_bits = _impl_._has_bits_[0];
379   if (cached_has_bits & 0x0000003fu) {
380     // optional string trace_name = 2;
381     if (cached_has_bits & 0x00000001u) {
382       total_size += 1 +
383         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
384           this->_internal_trace_name());
385     }
386 
387     // optional string name = 4;
388     if (cached_has_bits & 0x00000002u) {
389       total_size += 1 +
390         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
391           this->_internal_name());
392     }
393 
394     // optional int32 pid = 1;
395     if (cached_has_bits & 0x00000004u) {
396       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
397     }
398 
399     // optional uint32 trace_begin = 3;
400     if (cached_has_bits & 0x00000008u) {
401       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_trace_begin());
402     }
403 
404     // optional uint32 type = 5;
405     if (cached_has_bits & 0x00000010u) {
406       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_type());
407     }
408 
409     // optional int32 value = 6;
410     if (cached_has_bits & 0x00000020u) {
411       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_value());
412     }
413 
414   }
415   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
416     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
417   }
418   int cached_size = ::_pbi::ToCachedSize(total_size);
419   SetCachedSize(cached_size);
420   return total_size;
421 }
422 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)423 void DpuTracingMarkWriteFtraceEvent::CheckTypeAndMergeFrom(
424     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
425   MergeFrom(*::_pbi::DownCast<const DpuTracingMarkWriteFtraceEvent*>(
426       &from));
427 }
428 
MergeFrom(const DpuTracingMarkWriteFtraceEvent & from)429 void DpuTracingMarkWriteFtraceEvent::MergeFrom(const DpuTracingMarkWriteFtraceEvent& from) {
430   DpuTracingMarkWriteFtraceEvent* const _this = this;
431   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
432   GOOGLE_DCHECK_NE(&from, _this);
433   ::uint32_t cached_has_bits = 0;
434   (void) cached_has_bits;
435 
436   cached_has_bits = from._impl_._has_bits_[0];
437   if (cached_has_bits & 0x0000003fu) {
438     if (cached_has_bits & 0x00000001u) {
439       _this->_internal_set_trace_name(from._internal_trace_name());
440     }
441     if (cached_has_bits & 0x00000002u) {
442       _this->_internal_set_name(from._internal_name());
443     }
444     if (cached_has_bits & 0x00000004u) {
445       _this->_impl_.pid_ = from._impl_.pid_;
446     }
447     if (cached_has_bits & 0x00000008u) {
448       _this->_impl_.trace_begin_ = from._impl_.trace_begin_;
449     }
450     if (cached_has_bits & 0x00000010u) {
451       _this->_impl_.type_ = from._impl_.type_;
452     }
453     if (cached_has_bits & 0x00000020u) {
454       _this->_impl_.value_ = from._impl_.value_;
455     }
456     _this->_impl_._has_bits_[0] |= cached_has_bits;
457   }
458   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
459 }
460 
CopyFrom(const DpuTracingMarkWriteFtraceEvent & from)461 void DpuTracingMarkWriteFtraceEvent::CopyFrom(const DpuTracingMarkWriteFtraceEvent& from) {
462 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DpuTracingMarkWriteFtraceEvent)
463   if (&from == this) return;
464   Clear();
465   MergeFrom(from);
466 }
467 
IsInitialized() const468 bool DpuTracingMarkWriteFtraceEvent::IsInitialized() const {
469   return true;
470 }
471 
InternalSwap(DpuTracingMarkWriteFtraceEvent * other)472 void DpuTracingMarkWriteFtraceEvent::InternalSwap(DpuTracingMarkWriteFtraceEvent* other) {
473   using std::swap;
474   auto* lhs_arena = GetArenaForAllocation();
475   auto* rhs_arena = other->GetArenaForAllocation();
476   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
477   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
478   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
479       &_impl_.trace_name_, lhs_arena,
480       &other->_impl_.trace_name_, rhs_arena
481   );
482   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
483       &_impl_.name_, lhs_arena,
484       &other->_impl_.name_, rhs_arena
485   );
486   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
487       PROTOBUF_FIELD_OFFSET(DpuTracingMarkWriteFtraceEvent, _impl_.value_)
488       + sizeof(DpuTracingMarkWriteFtraceEvent::_impl_.value_)  // NOLINT
489       - PROTOBUF_FIELD_OFFSET(DpuTracingMarkWriteFtraceEvent, _impl_.pid_)>(
490           reinterpret_cast<char*>(&_impl_.pid_),
491           reinterpret_cast<char*>(&other->_impl_.pid_));
492 }
493 
GetTypeName() const494 std::string DpuTracingMarkWriteFtraceEvent::GetTypeName() const {
495   return "perfetto.protos.DpuTracingMarkWriteFtraceEvent";
496 }
497 
498 
499 // ===================================================================
500 
501 class DpuDsiCmdFifoStatusFtraceEvent::_Internal {
502  public:
503   using HasBits = decltype(std::declval<DpuDsiCmdFifoStatusFtraceEvent>()._impl_._has_bits_);
set_has_header(HasBits * has_bits)504   static void set_has_header(HasBits* has_bits) {
505     (*has_bits)[0] |= 1u;
506   }
set_has_payload(HasBits * has_bits)507   static void set_has_payload(HasBits* has_bits) {
508     (*has_bits)[0] |= 2u;
509   }
510 };
511 
DpuDsiCmdFifoStatusFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)512 DpuDsiCmdFifoStatusFtraceEvent::DpuDsiCmdFifoStatusFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
513                          bool is_message_owned)
514   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
515   SharedCtor(arena, is_message_owned);
516   // @@protoc_insertion_point(arena_constructor:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
517 }
DpuDsiCmdFifoStatusFtraceEvent(const DpuDsiCmdFifoStatusFtraceEvent & from)518 DpuDsiCmdFifoStatusFtraceEvent::DpuDsiCmdFifoStatusFtraceEvent(const DpuDsiCmdFifoStatusFtraceEvent& from)
519   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
520   DpuDsiCmdFifoStatusFtraceEvent* const _this = this; (void)_this;
521   new (&_impl_) Impl_{
522       decltype(_impl_._has_bits_){from._impl_._has_bits_}
523     , /*decltype(_impl_._cached_size_)*/{}
524     , decltype(_impl_.header_){}
525     , decltype(_impl_.payload_){}};
526 
527   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
528   ::memcpy(&_impl_.header_, &from._impl_.header_,
529     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.payload_) -
530     reinterpret_cast<char*>(&_impl_.header_)) + sizeof(_impl_.payload_));
531   // @@protoc_insertion_point(copy_constructor:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
532 }
533 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)534 inline void DpuDsiCmdFifoStatusFtraceEvent::SharedCtor(
535     ::_pb::Arena* arena, bool is_message_owned) {
536   (void)arena;
537   (void)is_message_owned;
538   new (&_impl_) Impl_{
539       decltype(_impl_._has_bits_){}
540     , /*decltype(_impl_._cached_size_)*/{}
541     , decltype(_impl_.header_){0u}
542     , decltype(_impl_.payload_){0u}
543   };
544 }
545 
~DpuDsiCmdFifoStatusFtraceEvent()546 DpuDsiCmdFifoStatusFtraceEvent::~DpuDsiCmdFifoStatusFtraceEvent() {
547   // @@protoc_insertion_point(destructor:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
548   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
549   (void)arena;
550     return;
551   }
552   SharedDtor();
553 }
554 
SharedDtor()555 inline void DpuDsiCmdFifoStatusFtraceEvent::SharedDtor() {
556   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
557 }
558 
SetCachedSize(int size) const559 void DpuDsiCmdFifoStatusFtraceEvent::SetCachedSize(int size) const {
560   _impl_._cached_size_.Set(size);
561 }
562 
Clear()563 void DpuDsiCmdFifoStatusFtraceEvent::Clear() {
564 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
565   ::uint32_t cached_has_bits = 0;
566   // Prevent compiler warnings about cached_has_bits being unused
567   (void) cached_has_bits;
568 
569   cached_has_bits = _impl_._has_bits_[0];
570   if (cached_has_bits & 0x00000003u) {
571     ::memset(&_impl_.header_, 0, static_cast<size_t>(
572         reinterpret_cast<char*>(&_impl_.payload_) -
573         reinterpret_cast<char*>(&_impl_.header_)) + sizeof(_impl_.payload_));
574   }
575   _impl_._has_bits_.Clear();
576   _internal_metadata_.Clear<std::string>();
577 }
578 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)579 const char* DpuDsiCmdFifoStatusFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
580 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
581   _Internal::HasBits has_bits{};
582   while (!ctx->Done(&ptr)) {
583     ::uint32_t tag;
584     ptr = ::_pbi::ReadTag(ptr, &tag);
585     switch (tag >> 3) {
586       // optional uint32 header = 1;
587       case 1:
588         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
589           _Internal::set_has_header(&has_bits);
590           _impl_.header_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
591           CHK_(ptr);
592         } else {
593           goto handle_unusual;
594         }
595         continue;
596       // optional uint32 payload = 2;
597       case 2:
598         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
599           _Internal::set_has_payload(&has_bits);
600           _impl_.payload_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
601           CHK_(ptr);
602         } else {
603           goto handle_unusual;
604         }
605         continue;
606       default:
607         goto handle_unusual;
608     }  // switch
609   handle_unusual:
610     if ((tag == 0) || ((tag & 7) == 4)) {
611       CHK_(ptr);
612       ctx->SetLastTag(tag);
613       goto message_done;
614     }
615     ptr = UnknownFieldParse(
616         tag,
617         _internal_metadata_.mutable_unknown_fields<std::string>(),
618         ptr, ctx);
619     CHK_(ptr != nullptr);
620   }  // while
621 message_done:
622   _impl_._has_bits_.Or(has_bits);
623   return ptr;
624 failure:
625   ptr = nullptr;
626   goto message_done;
627 #undef CHK_
628 }
629 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const630 ::uint8_t* DpuDsiCmdFifoStatusFtraceEvent::_InternalSerialize(
631     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
632   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
633   ::uint32_t cached_has_bits = 0;
634   (void) cached_has_bits;
635 
636   cached_has_bits = _impl_._has_bits_[0];
637   // optional uint32 header = 1;
638   if (cached_has_bits & 0x00000001u) {
639     target = stream->EnsureSpace(target);
640     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_header(), target);
641   }
642 
643   // optional uint32 payload = 2;
644   if (cached_has_bits & 0x00000002u) {
645     target = stream->EnsureSpace(target);
646     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_payload(), target);
647   }
648 
649   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
650     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
651         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
652   }
653   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
654   return target;
655 }
656 
ByteSizeLong() const657 size_t DpuDsiCmdFifoStatusFtraceEvent::ByteSizeLong() const {
658 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
659   size_t total_size = 0;
660 
661   ::uint32_t cached_has_bits = 0;
662   // Prevent compiler warnings about cached_has_bits being unused
663   (void) cached_has_bits;
664 
665   cached_has_bits = _impl_._has_bits_[0];
666   if (cached_has_bits & 0x00000003u) {
667     // optional uint32 header = 1;
668     if (cached_has_bits & 0x00000001u) {
669       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_header());
670     }
671 
672     // optional uint32 payload = 2;
673     if (cached_has_bits & 0x00000002u) {
674       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_payload());
675     }
676 
677   }
678   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
679     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
680   }
681   int cached_size = ::_pbi::ToCachedSize(total_size);
682   SetCachedSize(cached_size);
683   return total_size;
684 }
685 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)686 void DpuDsiCmdFifoStatusFtraceEvent::CheckTypeAndMergeFrom(
687     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
688   MergeFrom(*::_pbi::DownCast<const DpuDsiCmdFifoStatusFtraceEvent*>(
689       &from));
690 }
691 
MergeFrom(const DpuDsiCmdFifoStatusFtraceEvent & from)692 void DpuDsiCmdFifoStatusFtraceEvent::MergeFrom(const DpuDsiCmdFifoStatusFtraceEvent& from) {
693   DpuDsiCmdFifoStatusFtraceEvent* const _this = this;
694   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
695   GOOGLE_DCHECK_NE(&from, _this);
696   ::uint32_t cached_has_bits = 0;
697   (void) cached_has_bits;
698 
699   cached_has_bits = from._impl_._has_bits_[0];
700   if (cached_has_bits & 0x00000003u) {
701     if (cached_has_bits & 0x00000001u) {
702       _this->_impl_.header_ = from._impl_.header_;
703     }
704     if (cached_has_bits & 0x00000002u) {
705       _this->_impl_.payload_ = from._impl_.payload_;
706     }
707     _this->_impl_._has_bits_[0] |= cached_has_bits;
708   }
709   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
710 }
711 
CopyFrom(const DpuDsiCmdFifoStatusFtraceEvent & from)712 void DpuDsiCmdFifoStatusFtraceEvent::CopyFrom(const DpuDsiCmdFifoStatusFtraceEvent& from) {
713 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent)
714   if (&from == this) return;
715   Clear();
716   MergeFrom(from);
717 }
718 
IsInitialized() const719 bool DpuDsiCmdFifoStatusFtraceEvent::IsInitialized() const {
720   return true;
721 }
722 
InternalSwap(DpuDsiCmdFifoStatusFtraceEvent * other)723 void DpuDsiCmdFifoStatusFtraceEvent::InternalSwap(DpuDsiCmdFifoStatusFtraceEvent* other) {
724   using std::swap;
725   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
726   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
727   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
728       PROTOBUF_FIELD_OFFSET(DpuDsiCmdFifoStatusFtraceEvent, _impl_.payload_)
729       + sizeof(DpuDsiCmdFifoStatusFtraceEvent::_impl_.payload_)  // NOLINT
730       - PROTOBUF_FIELD_OFFSET(DpuDsiCmdFifoStatusFtraceEvent, _impl_.header_)>(
731           reinterpret_cast<char*>(&_impl_.header_),
732           reinterpret_cast<char*>(&other->_impl_.header_));
733 }
734 
GetTypeName() const735 std::string DpuDsiCmdFifoStatusFtraceEvent::GetTypeName() const {
736   return "perfetto.protos.DpuDsiCmdFifoStatusFtraceEvent";
737 }
738 
739 
740 // ===================================================================
741 
742 class DpuDsiRxFtraceEvent::_Internal {
743  public:
744   using HasBits = decltype(std::declval<DpuDsiRxFtraceEvent>()._impl_._has_bits_);
set_has_cmd(HasBits * has_bits)745   static void set_has_cmd(HasBits* has_bits) {
746     (*has_bits)[0] |= 1u;
747   }
set_has_rx_buf(HasBits * has_bits)748   static void set_has_rx_buf(HasBits* has_bits) {
749     (*has_bits)[0] |= 2u;
750   }
751 };
752 
DpuDsiRxFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)753 DpuDsiRxFtraceEvent::DpuDsiRxFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
754                          bool is_message_owned)
755   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
756   SharedCtor(arena, is_message_owned);
757   // @@protoc_insertion_point(arena_constructor:perfetto.protos.DpuDsiRxFtraceEvent)
758 }
DpuDsiRxFtraceEvent(const DpuDsiRxFtraceEvent & from)759 DpuDsiRxFtraceEvent::DpuDsiRxFtraceEvent(const DpuDsiRxFtraceEvent& from)
760   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
761   DpuDsiRxFtraceEvent* const _this = this; (void)_this;
762   new (&_impl_) Impl_{
763       decltype(_impl_._has_bits_){from._impl_._has_bits_}
764     , /*decltype(_impl_._cached_size_)*/{}
765     , decltype(_impl_.cmd_){}
766     , decltype(_impl_.rx_buf_){}};
767 
768   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
769   ::memcpy(&_impl_.cmd_, &from._impl_.cmd_,
770     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.rx_buf_) -
771     reinterpret_cast<char*>(&_impl_.cmd_)) + sizeof(_impl_.rx_buf_));
772   // @@protoc_insertion_point(copy_constructor:perfetto.protos.DpuDsiRxFtraceEvent)
773 }
774 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)775 inline void DpuDsiRxFtraceEvent::SharedCtor(
776     ::_pb::Arena* arena, bool is_message_owned) {
777   (void)arena;
778   (void)is_message_owned;
779   new (&_impl_) Impl_{
780       decltype(_impl_._has_bits_){}
781     , /*decltype(_impl_._cached_size_)*/{}
782     , decltype(_impl_.cmd_){0u}
783     , decltype(_impl_.rx_buf_){0u}
784   };
785 }
786 
~DpuDsiRxFtraceEvent()787 DpuDsiRxFtraceEvent::~DpuDsiRxFtraceEvent() {
788   // @@protoc_insertion_point(destructor:perfetto.protos.DpuDsiRxFtraceEvent)
789   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
790   (void)arena;
791     return;
792   }
793   SharedDtor();
794 }
795 
SharedDtor()796 inline void DpuDsiRxFtraceEvent::SharedDtor() {
797   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
798 }
799 
SetCachedSize(int size) const800 void DpuDsiRxFtraceEvent::SetCachedSize(int size) const {
801   _impl_._cached_size_.Set(size);
802 }
803 
Clear()804 void DpuDsiRxFtraceEvent::Clear() {
805 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DpuDsiRxFtraceEvent)
806   ::uint32_t cached_has_bits = 0;
807   // Prevent compiler warnings about cached_has_bits being unused
808   (void) cached_has_bits;
809 
810   cached_has_bits = _impl_._has_bits_[0];
811   if (cached_has_bits & 0x00000003u) {
812     ::memset(&_impl_.cmd_, 0, static_cast<size_t>(
813         reinterpret_cast<char*>(&_impl_.rx_buf_) -
814         reinterpret_cast<char*>(&_impl_.cmd_)) + sizeof(_impl_.rx_buf_));
815   }
816   _impl_._has_bits_.Clear();
817   _internal_metadata_.Clear<std::string>();
818 }
819 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)820 const char* DpuDsiRxFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
821 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
822   _Internal::HasBits has_bits{};
823   while (!ctx->Done(&ptr)) {
824     ::uint32_t tag;
825     ptr = ::_pbi::ReadTag(ptr, &tag);
826     switch (tag >> 3) {
827       // optional uint32 cmd = 1;
828       case 1:
829         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
830           _Internal::set_has_cmd(&has_bits);
831           _impl_.cmd_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
832           CHK_(ptr);
833         } else {
834           goto handle_unusual;
835         }
836         continue;
837       // optional uint32 rx_buf = 2;
838       case 2:
839         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
840           _Internal::set_has_rx_buf(&has_bits);
841           _impl_.rx_buf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
842           CHK_(ptr);
843         } else {
844           goto handle_unusual;
845         }
846         continue;
847       default:
848         goto handle_unusual;
849     }  // switch
850   handle_unusual:
851     if ((tag == 0) || ((tag & 7) == 4)) {
852       CHK_(ptr);
853       ctx->SetLastTag(tag);
854       goto message_done;
855     }
856     ptr = UnknownFieldParse(
857         tag,
858         _internal_metadata_.mutable_unknown_fields<std::string>(),
859         ptr, ctx);
860     CHK_(ptr != nullptr);
861   }  // while
862 message_done:
863   _impl_._has_bits_.Or(has_bits);
864   return ptr;
865 failure:
866   ptr = nullptr;
867   goto message_done;
868 #undef CHK_
869 }
870 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const871 ::uint8_t* DpuDsiRxFtraceEvent::_InternalSerialize(
872     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
873   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DpuDsiRxFtraceEvent)
874   ::uint32_t cached_has_bits = 0;
875   (void) cached_has_bits;
876 
877   cached_has_bits = _impl_._has_bits_[0];
878   // optional uint32 cmd = 1;
879   if (cached_has_bits & 0x00000001u) {
880     target = stream->EnsureSpace(target);
881     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_cmd(), target);
882   }
883 
884   // optional uint32 rx_buf = 2;
885   if (cached_has_bits & 0x00000002u) {
886     target = stream->EnsureSpace(target);
887     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_rx_buf(), target);
888   }
889 
890   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
891     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
892         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
893   }
894   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DpuDsiRxFtraceEvent)
895   return target;
896 }
897 
ByteSizeLong() const898 size_t DpuDsiRxFtraceEvent::ByteSizeLong() const {
899 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DpuDsiRxFtraceEvent)
900   size_t total_size = 0;
901 
902   ::uint32_t cached_has_bits = 0;
903   // Prevent compiler warnings about cached_has_bits being unused
904   (void) cached_has_bits;
905 
906   cached_has_bits = _impl_._has_bits_[0];
907   if (cached_has_bits & 0x00000003u) {
908     // optional uint32 cmd = 1;
909     if (cached_has_bits & 0x00000001u) {
910       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cmd());
911     }
912 
913     // optional uint32 rx_buf = 2;
914     if (cached_has_bits & 0x00000002u) {
915       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rx_buf());
916     }
917 
918   }
919   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
920     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
921   }
922   int cached_size = ::_pbi::ToCachedSize(total_size);
923   SetCachedSize(cached_size);
924   return total_size;
925 }
926 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)927 void DpuDsiRxFtraceEvent::CheckTypeAndMergeFrom(
928     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
929   MergeFrom(*::_pbi::DownCast<const DpuDsiRxFtraceEvent*>(
930       &from));
931 }
932 
MergeFrom(const DpuDsiRxFtraceEvent & from)933 void DpuDsiRxFtraceEvent::MergeFrom(const DpuDsiRxFtraceEvent& from) {
934   DpuDsiRxFtraceEvent* const _this = this;
935   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DpuDsiRxFtraceEvent)
936   GOOGLE_DCHECK_NE(&from, _this);
937   ::uint32_t cached_has_bits = 0;
938   (void) cached_has_bits;
939 
940   cached_has_bits = from._impl_._has_bits_[0];
941   if (cached_has_bits & 0x00000003u) {
942     if (cached_has_bits & 0x00000001u) {
943       _this->_impl_.cmd_ = from._impl_.cmd_;
944     }
945     if (cached_has_bits & 0x00000002u) {
946       _this->_impl_.rx_buf_ = from._impl_.rx_buf_;
947     }
948     _this->_impl_._has_bits_[0] |= cached_has_bits;
949   }
950   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
951 }
952 
CopyFrom(const DpuDsiRxFtraceEvent & from)953 void DpuDsiRxFtraceEvent::CopyFrom(const DpuDsiRxFtraceEvent& from) {
954 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DpuDsiRxFtraceEvent)
955   if (&from == this) return;
956   Clear();
957   MergeFrom(from);
958 }
959 
IsInitialized() const960 bool DpuDsiRxFtraceEvent::IsInitialized() const {
961   return true;
962 }
963 
InternalSwap(DpuDsiRxFtraceEvent * other)964 void DpuDsiRxFtraceEvent::InternalSwap(DpuDsiRxFtraceEvent* other) {
965   using std::swap;
966   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
967   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
968   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
969       PROTOBUF_FIELD_OFFSET(DpuDsiRxFtraceEvent, _impl_.rx_buf_)
970       + sizeof(DpuDsiRxFtraceEvent::_impl_.rx_buf_)  // NOLINT
971       - PROTOBUF_FIELD_OFFSET(DpuDsiRxFtraceEvent, _impl_.cmd_)>(
972           reinterpret_cast<char*>(&_impl_.cmd_),
973           reinterpret_cast<char*>(&other->_impl_.cmd_));
974 }
975 
GetTypeName() const976 std::string DpuDsiRxFtraceEvent::GetTypeName() const {
977   return "perfetto.protos.DpuDsiRxFtraceEvent";
978 }
979 
980 
981 // ===================================================================
982 
983 class DpuDsiTxFtraceEvent::_Internal {
984  public:
985   using HasBits = decltype(std::declval<DpuDsiTxFtraceEvent>()._impl_._has_bits_);
set_has_type(HasBits * has_bits)986   static void set_has_type(HasBits* has_bits) {
987     (*has_bits)[0] |= 1u;
988   }
set_has_tx_buf(HasBits * has_bits)989   static void set_has_tx_buf(HasBits* has_bits) {
990     (*has_bits)[0] |= 2u;
991   }
set_has_last(HasBits * has_bits)992   static void set_has_last(HasBits* has_bits) {
993     (*has_bits)[0] |= 4u;
994   }
set_has_delay_ms(HasBits * has_bits)995   static void set_has_delay_ms(HasBits* has_bits) {
996     (*has_bits)[0] |= 8u;
997   }
998 };
999 
DpuDsiTxFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1000 DpuDsiTxFtraceEvent::DpuDsiTxFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1001                          bool is_message_owned)
1002   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1003   SharedCtor(arena, is_message_owned);
1004   // @@protoc_insertion_point(arena_constructor:perfetto.protos.DpuDsiTxFtraceEvent)
1005 }
DpuDsiTxFtraceEvent(const DpuDsiTxFtraceEvent & from)1006 DpuDsiTxFtraceEvent::DpuDsiTxFtraceEvent(const DpuDsiTxFtraceEvent& from)
1007   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1008   DpuDsiTxFtraceEvent* const _this = this; (void)_this;
1009   new (&_impl_) Impl_{
1010       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1011     , /*decltype(_impl_._cached_size_)*/{}
1012     , decltype(_impl_.type_){}
1013     , decltype(_impl_.tx_buf_){}
1014     , decltype(_impl_.last_){}
1015     , decltype(_impl_.delay_ms_){}};
1016 
1017   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1018   ::memcpy(&_impl_.type_, &from._impl_.type_,
1019     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.delay_ms_) -
1020     reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.delay_ms_));
1021   // @@protoc_insertion_point(copy_constructor:perfetto.protos.DpuDsiTxFtraceEvent)
1022 }
1023 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1024 inline void DpuDsiTxFtraceEvent::SharedCtor(
1025     ::_pb::Arena* arena, bool is_message_owned) {
1026   (void)arena;
1027   (void)is_message_owned;
1028   new (&_impl_) Impl_{
1029       decltype(_impl_._has_bits_){}
1030     , /*decltype(_impl_._cached_size_)*/{}
1031     , decltype(_impl_.type_){0u}
1032     , decltype(_impl_.tx_buf_){0u}
1033     , decltype(_impl_.last_){0u}
1034     , decltype(_impl_.delay_ms_){0u}
1035   };
1036 }
1037 
~DpuDsiTxFtraceEvent()1038 DpuDsiTxFtraceEvent::~DpuDsiTxFtraceEvent() {
1039   // @@protoc_insertion_point(destructor:perfetto.protos.DpuDsiTxFtraceEvent)
1040   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1041   (void)arena;
1042     return;
1043   }
1044   SharedDtor();
1045 }
1046 
SharedDtor()1047 inline void DpuDsiTxFtraceEvent::SharedDtor() {
1048   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1049 }
1050 
SetCachedSize(int size) const1051 void DpuDsiTxFtraceEvent::SetCachedSize(int size) const {
1052   _impl_._cached_size_.Set(size);
1053 }
1054 
Clear()1055 void DpuDsiTxFtraceEvent::Clear() {
1056 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DpuDsiTxFtraceEvent)
1057   ::uint32_t cached_has_bits = 0;
1058   // Prevent compiler warnings about cached_has_bits being unused
1059   (void) cached_has_bits;
1060 
1061   cached_has_bits = _impl_._has_bits_[0];
1062   if (cached_has_bits & 0x0000000fu) {
1063     ::memset(&_impl_.type_, 0, static_cast<size_t>(
1064         reinterpret_cast<char*>(&_impl_.delay_ms_) -
1065         reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.delay_ms_));
1066   }
1067   _impl_._has_bits_.Clear();
1068   _internal_metadata_.Clear<std::string>();
1069 }
1070 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1071 const char* DpuDsiTxFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1072 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1073   _Internal::HasBits has_bits{};
1074   while (!ctx->Done(&ptr)) {
1075     ::uint32_t tag;
1076     ptr = ::_pbi::ReadTag(ptr, &tag);
1077     switch (tag >> 3) {
1078       // optional uint32 type = 1;
1079       case 1:
1080         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1081           _Internal::set_has_type(&has_bits);
1082           _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1083           CHK_(ptr);
1084         } else {
1085           goto handle_unusual;
1086         }
1087         continue;
1088       // optional uint32 tx_buf = 2;
1089       case 2:
1090         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1091           _Internal::set_has_tx_buf(&has_bits);
1092           _impl_.tx_buf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1093           CHK_(ptr);
1094         } else {
1095           goto handle_unusual;
1096         }
1097         continue;
1098       // optional uint32 last = 3;
1099       case 3:
1100         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1101           _Internal::set_has_last(&has_bits);
1102           _impl_.last_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1103           CHK_(ptr);
1104         } else {
1105           goto handle_unusual;
1106         }
1107         continue;
1108       // optional uint32 delay_ms = 4;
1109       case 4:
1110         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1111           _Internal::set_has_delay_ms(&has_bits);
1112           _impl_.delay_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1113           CHK_(ptr);
1114         } else {
1115           goto handle_unusual;
1116         }
1117         continue;
1118       default:
1119         goto handle_unusual;
1120     }  // switch
1121   handle_unusual:
1122     if ((tag == 0) || ((tag & 7) == 4)) {
1123       CHK_(ptr);
1124       ctx->SetLastTag(tag);
1125       goto message_done;
1126     }
1127     ptr = UnknownFieldParse(
1128         tag,
1129         _internal_metadata_.mutable_unknown_fields<std::string>(),
1130         ptr, ctx);
1131     CHK_(ptr != nullptr);
1132   }  // while
1133 message_done:
1134   _impl_._has_bits_.Or(has_bits);
1135   return ptr;
1136 failure:
1137   ptr = nullptr;
1138   goto message_done;
1139 #undef CHK_
1140 }
1141 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1142 ::uint8_t* DpuDsiTxFtraceEvent::_InternalSerialize(
1143     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1144   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DpuDsiTxFtraceEvent)
1145   ::uint32_t cached_has_bits = 0;
1146   (void) cached_has_bits;
1147 
1148   cached_has_bits = _impl_._has_bits_[0];
1149   // optional uint32 type = 1;
1150   if (cached_has_bits & 0x00000001u) {
1151     target = stream->EnsureSpace(target);
1152     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type(), target);
1153   }
1154 
1155   // optional uint32 tx_buf = 2;
1156   if (cached_has_bits & 0x00000002u) {
1157     target = stream->EnsureSpace(target);
1158     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_tx_buf(), target);
1159   }
1160 
1161   // optional uint32 last = 3;
1162   if (cached_has_bits & 0x00000004u) {
1163     target = stream->EnsureSpace(target);
1164     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_last(), target);
1165   }
1166 
1167   // optional uint32 delay_ms = 4;
1168   if (cached_has_bits & 0x00000008u) {
1169     target = stream->EnsureSpace(target);
1170     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_delay_ms(), target);
1171   }
1172 
1173   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1174     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1175         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1176   }
1177   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DpuDsiTxFtraceEvent)
1178   return target;
1179 }
1180 
ByteSizeLong() const1181 size_t DpuDsiTxFtraceEvent::ByteSizeLong() const {
1182 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DpuDsiTxFtraceEvent)
1183   size_t total_size = 0;
1184 
1185   ::uint32_t cached_has_bits = 0;
1186   // Prevent compiler warnings about cached_has_bits being unused
1187   (void) cached_has_bits;
1188 
1189   cached_has_bits = _impl_._has_bits_[0];
1190   if (cached_has_bits & 0x0000000fu) {
1191     // optional uint32 type = 1;
1192     if (cached_has_bits & 0x00000001u) {
1193       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_type());
1194     }
1195 
1196     // optional uint32 tx_buf = 2;
1197     if (cached_has_bits & 0x00000002u) {
1198       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_tx_buf());
1199     }
1200 
1201     // optional uint32 last = 3;
1202     if (cached_has_bits & 0x00000004u) {
1203       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_last());
1204     }
1205 
1206     // optional uint32 delay_ms = 4;
1207     if (cached_has_bits & 0x00000008u) {
1208       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_delay_ms());
1209     }
1210 
1211   }
1212   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1213     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1214   }
1215   int cached_size = ::_pbi::ToCachedSize(total_size);
1216   SetCachedSize(cached_size);
1217   return total_size;
1218 }
1219 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1220 void DpuDsiTxFtraceEvent::CheckTypeAndMergeFrom(
1221     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1222   MergeFrom(*::_pbi::DownCast<const DpuDsiTxFtraceEvent*>(
1223       &from));
1224 }
1225 
MergeFrom(const DpuDsiTxFtraceEvent & from)1226 void DpuDsiTxFtraceEvent::MergeFrom(const DpuDsiTxFtraceEvent& from) {
1227   DpuDsiTxFtraceEvent* const _this = this;
1228   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DpuDsiTxFtraceEvent)
1229   GOOGLE_DCHECK_NE(&from, _this);
1230   ::uint32_t cached_has_bits = 0;
1231   (void) cached_has_bits;
1232 
1233   cached_has_bits = from._impl_._has_bits_[0];
1234   if (cached_has_bits & 0x0000000fu) {
1235     if (cached_has_bits & 0x00000001u) {
1236       _this->_impl_.type_ = from._impl_.type_;
1237     }
1238     if (cached_has_bits & 0x00000002u) {
1239       _this->_impl_.tx_buf_ = from._impl_.tx_buf_;
1240     }
1241     if (cached_has_bits & 0x00000004u) {
1242       _this->_impl_.last_ = from._impl_.last_;
1243     }
1244     if (cached_has_bits & 0x00000008u) {
1245       _this->_impl_.delay_ms_ = from._impl_.delay_ms_;
1246     }
1247     _this->_impl_._has_bits_[0] |= cached_has_bits;
1248   }
1249   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1250 }
1251 
CopyFrom(const DpuDsiTxFtraceEvent & from)1252 void DpuDsiTxFtraceEvent::CopyFrom(const DpuDsiTxFtraceEvent& from) {
1253 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DpuDsiTxFtraceEvent)
1254   if (&from == this) return;
1255   Clear();
1256   MergeFrom(from);
1257 }
1258 
IsInitialized() const1259 bool DpuDsiTxFtraceEvent::IsInitialized() const {
1260   return true;
1261 }
1262 
InternalSwap(DpuDsiTxFtraceEvent * other)1263 void DpuDsiTxFtraceEvent::InternalSwap(DpuDsiTxFtraceEvent* other) {
1264   using std::swap;
1265   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1266   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1267   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1268       PROTOBUF_FIELD_OFFSET(DpuDsiTxFtraceEvent, _impl_.delay_ms_)
1269       + sizeof(DpuDsiTxFtraceEvent::_impl_.delay_ms_)  // NOLINT
1270       - PROTOBUF_FIELD_OFFSET(DpuDsiTxFtraceEvent, _impl_.type_)>(
1271           reinterpret_cast<char*>(&_impl_.type_),
1272           reinterpret_cast<char*>(&other->_impl_.type_));
1273 }
1274 
GetTypeName() const1275 std::string DpuDsiTxFtraceEvent::GetTypeName() const {
1276   return "perfetto.protos.DpuDsiTxFtraceEvent";
1277 }
1278 
1279 
1280 // @@protoc_insertion_point(namespace_scope)
1281 }  // namespace protos
1282 }  // namespace perfetto
1283 PROTOBUF_NAMESPACE_OPEN
1284 template<> PROTOBUF_NOINLINE ::perfetto::protos::DpuTracingMarkWriteFtraceEvent*
CreateMaybeMessage(Arena * arena)1285 Arena::CreateMaybeMessage< ::perfetto::protos::DpuTracingMarkWriteFtraceEvent >(Arena* arena) {
1286   return Arena::CreateMessageInternal< ::perfetto::protos::DpuTracingMarkWriteFtraceEvent >(arena);
1287 }
1288 template<> PROTOBUF_NOINLINE ::perfetto::protos::DpuDsiCmdFifoStatusFtraceEvent*
CreateMaybeMessage(Arena * arena)1289 Arena::CreateMaybeMessage< ::perfetto::protos::DpuDsiCmdFifoStatusFtraceEvent >(Arena* arena) {
1290   return Arena::CreateMessageInternal< ::perfetto::protos::DpuDsiCmdFifoStatusFtraceEvent >(arena);
1291 }
1292 template<> PROTOBUF_NOINLINE ::perfetto::protos::DpuDsiRxFtraceEvent*
CreateMaybeMessage(Arena * arena)1293 Arena::CreateMaybeMessage< ::perfetto::protos::DpuDsiRxFtraceEvent >(Arena* arena) {
1294   return Arena::CreateMessageInternal< ::perfetto::protos::DpuDsiRxFtraceEvent >(arena);
1295 }
1296 template<> PROTOBUF_NOINLINE ::perfetto::protos::DpuDsiTxFtraceEvent*
CreateMaybeMessage(Arena * arena)1297 Arena::CreateMaybeMessage< ::perfetto::protos::DpuDsiTxFtraceEvent >(Arena* arena) {
1298   return Arena::CreateMessageInternal< ::perfetto::protos::DpuDsiTxFtraceEvent >(arena);
1299 }
1300 PROTOBUF_NAMESPACE_CLOSE
1301 
1302 // @@protoc_insertion_point(global_scope)
1303 #include <google/protobuf/port_undef.inc>
1304