1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/binder.proto
3
4 #include "protos/perfetto/trace/ftrace/binder.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 {
BinderTransactionFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR BinderTransactionFtraceEvent::BinderTransactionFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.debug_id_)*/0
28 , /*decltype(_impl_.target_node_)*/0
29 , /*decltype(_impl_.to_proc_)*/0
30 , /*decltype(_impl_.to_thread_)*/0
31 , /*decltype(_impl_.reply_)*/0
32 , /*decltype(_impl_.code_)*/0u
33 , /*decltype(_impl_.flags_)*/0u} {}
34 struct BinderTransactionFtraceEventDefaultTypeInternal {
BinderTransactionFtraceEventDefaultTypeInternalperfetto::protos::BinderTransactionFtraceEventDefaultTypeInternal35 PROTOBUF_CONSTEXPR BinderTransactionFtraceEventDefaultTypeInternal()
36 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderTransactionFtraceEventDefaultTypeInternalperfetto::protos::BinderTransactionFtraceEventDefaultTypeInternal37 ~BinderTransactionFtraceEventDefaultTypeInternal() {}
38 union { // NOLINT(misc-non-private-member-variables-in-classes)
39 BinderTransactionFtraceEvent _instance;
40 };
41 };
42 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderTransactionFtraceEventDefaultTypeInternal _BinderTransactionFtraceEvent_default_instance_;
BinderTransactionReceivedFtraceEvent(::_pbi::ConstantInitialized)43 PROTOBUF_CONSTEXPR BinderTransactionReceivedFtraceEvent::BinderTransactionReceivedFtraceEvent(
44 ::_pbi::ConstantInitialized): _impl_{
45 /*decltype(_impl_._has_bits_)*/{}
46 , /*decltype(_impl_._cached_size_)*/{}
47 , /*decltype(_impl_.debug_id_)*/0} {}
48 struct BinderTransactionReceivedFtraceEventDefaultTypeInternal {
BinderTransactionReceivedFtraceEventDefaultTypeInternalperfetto::protos::BinderTransactionReceivedFtraceEventDefaultTypeInternal49 PROTOBUF_CONSTEXPR BinderTransactionReceivedFtraceEventDefaultTypeInternal()
50 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderTransactionReceivedFtraceEventDefaultTypeInternalperfetto::protos::BinderTransactionReceivedFtraceEventDefaultTypeInternal51 ~BinderTransactionReceivedFtraceEventDefaultTypeInternal() {}
52 union { // NOLINT(misc-non-private-member-variables-in-classes)
53 BinderTransactionReceivedFtraceEvent _instance;
54 };
55 };
56 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderTransactionReceivedFtraceEventDefaultTypeInternal _BinderTransactionReceivedFtraceEvent_default_instance_;
BinderSetPriorityFtraceEvent(::_pbi::ConstantInitialized)57 PROTOBUF_CONSTEXPR BinderSetPriorityFtraceEvent::BinderSetPriorityFtraceEvent(
58 ::_pbi::ConstantInitialized): _impl_{
59 /*decltype(_impl_._has_bits_)*/{}
60 , /*decltype(_impl_._cached_size_)*/{}
61 , /*decltype(_impl_.proc_)*/0
62 , /*decltype(_impl_.thread_)*/0
63 , /*decltype(_impl_.old_prio_)*/0u
64 , /*decltype(_impl_.new_prio_)*/0u
65 , /*decltype(_impl_.desired_prio_)*/0u} {}
66 struct BinderSetPriorityFtraceEventDefaultTypeInternal {
BinderSetPriorityFtraceEventDefaultTypeInternalperfetto::protos::BinderSetPriorityFtraceEventDefaultTypeInternal67 PROTOBUF_CONSTEXPR BinderSetPriorityFtraceEventDefaultTypeInternal()
68 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderSetPriorityFtraceEventDefaultTypeInternalperfetto::protos::BinderSetPriorityFtraceEventDefaultTypeInternal69 ~BinderSetPriorityFtraceEventDefaultTypeInternal() {}
70 union { // NOLINT(misc-non-private-member-variables-in-classes)
71 BinderSetPriorityFtraceEvent _instance;
72 };
73 };
74 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderSetPriorityFtraceEventDefaultTypeInternal _BinderSetPriorityFtraceEvent_default_instance_;
BinderLockFtraceEvent(::_pbi::ConstantInitialized)75 PROTOBUF_CONSTEXPR BinderLockFtraceEvent::BinderLockFtraceEvent(
76 ::_pbi::ConstantInitialized): _impl_{
77 /*decltype(_impl_._has_bits_)*/{}
78 , /*decltype(_impl_._cached_size_)*/{}
79 , /*decltype(_impl_.tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
80 struct BinderLockFtraceEventDefaultTypeInternal {
BinderLockFtraceEventDefaultTypeInternalperfetto::protos::BinderLockFtraceEventDefaultTypeInternal81 PROTOBUF_CONSTEXPR BinderLockFtraceEventDefaultTypeInternal()
82 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderLockFtraceEventDefaultTypeInternalperfetto::protos::BinderLockFtraceEventDefaultTypeInternal83 ~BinderLockFtraceEventDefaultTypeInternal() {}
84 union { // NOLINT(misc-non-private-member-variables-in-classes)
85 BinderLockFtraceEvent _instance;
86 };
87 };
88 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderLockFtraceEventDefaultTypeInternal _BinderLockFtraceEvent_default_instance_;
BinderLockedFtraceEvent(::_pbi::ConstantInitialized)89 PROTOBUF_CONSTEXPR BinderLockedFtraceEvent::BinderLockedFtraceEvent(
90 ::_pbi::ConstantInitialized): _impl_{
91 /*decltype(_impl_._has_bits_)*/{}
92 , /*decltype(_impl_._cached_size_)*/{}
93 , /*decltype(_impl_.tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
94 struct BinderLockedFtraceEventDefaultTypeInternal {
BinderLockedFtraceEventDefaultTypeInternalperfetto::protos::BinderLockedFtraceEventDefaultTypeInternal95 PROTOBUF_CONSTEXPR BinderLockedFtraceEventDefaultTypeInternal()
96 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderLockedFtraceEventDefaultTypeInternalperfetto::protos::BinderLockedFtraceEventDefaultTypeInternal97 ~BinderLockedFtraceEventDefaultTypeInternal() {}
98 union { // NOLINT(misc-non-private-member-variables-in-classes)
99 BinderLockedFtraceEvent _instance;
100 };
101 };
102 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderLockedFtraceEventDefaultTypeInternal _BinderLockedFtraceEvent_default_instance_;
BinderUnlockFtraceEvent(::_pbi::ConstantInitialized)103 PROTOBUF_CONSTEXPR BinderUnlockFtraceEvent::BinderUnlockFtraceEvent(
104 ::_pbi::ConstantInitialized): _impl_{
105 /*decltype(_impl_._has_bits_)*/{}
106 , /*decltype(_impl_._cached_size_)*/{}
107 , /*decltype(_impl_.tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
108 struct BinderUnlockFtraceEventDefaultTypeInternal {
BinderUnlockFtraceEventDefaultTypeInternalperfetto::protos::BinderUnlockFtraceEventDefaultTypeInternal109 PROTOBUF_CONSTEXPR BinderUnlockFtraceEventDefaultTypeInternal()
110 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderUnlockFtraceEventDefaultTypeInternalperfetto::protos::BinderUnlockFtraceEventDefaultTypeInternal111 ~BinderUnlockFtraceEventDefaultTypeInternal() {}
112 union { // NOLINT(misc-non-private-member-variables-in-classes)
113 BinderUnlockFtraceEvent _instance;
114 };
115 };
116 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderUnlockFtraceEventDefaultTypeInternal _BinderUnlockFtraceEvent_default_instance_;
BinderTransactionAllocBufFtraceEvent(::_pbi::ConstantInitialized)117 PROTOBUF_CONSTEXPR BinderTransactionAllocBufFtraceEvent::BinderTransactionAllocBufFtraceEvent(
118 ::_pbi::ConstantInitialized): _impl_{
119 /*decltype(_impl_._has_bits_)*/{}
120 , /*decltype(_impl_._cached_size_)*/{}
121 , /*decltype(_impl_.data_size_)*/::uint64_t{0u}
122 , /*decltype(_impl_.offsets_size_)*/::uint64_t{0u}
123 , /*decltype(_impl_.extra_buffers_size_)*/::uint64_t{0u}
124 , /*decltype(_impl_.debug_id_)*/0} {}
125 struct BinderTransactionAllocBufFtraceEventDefaultTypeInternal {
BinderTransactionAllocBufFtraceEventDefaultTypeInternalperfetto::protos::BinderTransactionAllocBufFtraceEventDefaultTypeInternal126 PROTOBUF_CONSTEXPR BinderTransactionAllocBufFtraceEventDefaultTypeInternal()
127 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderTransactionAllocBufFtraceEventDefaultTypeInternalperfetto::protos::BinderTransactionAllocBufFtraceEventDefaultTypeInternal128 ~BinderTransactionAllocBufFtraceEventDefaultTypeInternal() {}
129 union { // NOLINT(misc-non-private-member-variables-in-classes)
130 BinderTransactionAllocBufFtraceEvent _instance;
131 };
132 };
133 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderTransactionAllocBufFtraceEventDefaultTypeInternal _BinderTransactionAllocBufFtraceEvent_default_instance_;
BinderCommandFtraceEvent(::_pbi::ConstantInitialized)134 PROTOBUF_CONSTEXPR BinderCommandFtraceEvent::BinderCommandFtraceEvent(
135 ::_pbi::ConstantInitialized): _impl_{
136 /*decltype(_impl_._has_bits_)*/{}
137 , /*decltype(_impl_._cached_size_)*/{}
138 , /*decltype(_impl_.cmd_)*/0u} {}
139 struct BinderCommandFtraceEventDefaultTypeInternal {
BinderCommandFtraceEventDefaultTypeInternalperfetto::protos::BinderCommandFtraceEventDefaultTypeInternal140 PROTOBUF_CONSTEXPR BinderCommandFtraceEventDefaultTypeInternal()
141 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderCommandFtraceEventDefaultTypeInternalperfetto::protos::BinderCommandFtraceEventDefaultTypeInternal142 ~BinderCommandFtraceEventDefaultTypeInternal() {}
143 union { // NOLINT(misc-non-private-member-variables-in-classes)
144 BinderCommandFtraceEvent _instance;
145 };
146 };
147 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderCommandFtraceEventDefaultTypeInternal _BinderCommandFtraceEvent_default_instance_;
BinderReturnFtraceEvent(::_pbi::ConstantInitialized)148 PROTOBUF_CONSTEXPR BinderReturnFtraceEvent::BinderReturnFtraceEvent(
149 ::_pbi::ConstantInitialized): _impl_{
150 /*decltype(_impl_._has_bits_)*/{}
151 , /*decltype(_impl_._cached_size_)*/{}
152 , /*decltype(_impl_.cmd_)*/0u} {}
153 struct BinderReturnFtraceEventDefaultTypeInternal {
BinderReturnFtraceEventDefaultTypeInternalperfetto::protos::BinderReturnFtraceEventDefaultTypeInternal154 PROTOBUF_CONSTEXPR BinderReturnFtraceEventDefaultTypeInternal()
155 : _instance(::_pbi::ConstantInitialized{}) {}
~BinderReturnFtraceEventDefaultTypeInternalperfetto::protos::BinderReturnFtraceEventDefaultTypeInternal156 ~BinderReturnFtraceEventDefaultTypeInternal() {}
157 union { // NOLINT(misc-non-private-member-variables-in-classes)
158 BinderReturnFtraceEvent _instance;
159 };
160 };
161 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BinderReturnFtraceEventDefaultTypeInternal _BinderReturnFtraceEvent_default_instance_;
162 } // namespace protos
163 } // namespace perfetto
164 namespace perfetto {
165 namespace protos {
166
167 // ===================================================================
168
169 class BinderTransactionFtraceEvent::_Internal {
170 public:
171 using HasBits = decltype(std::declval<BinderTransactionFtraceEvent>()._impl_._has_bits_);
set_has_debug_id(HasBits * has_bits)172 static void set_has_debug_id(HasBits* has_bits) {
173 (*has_bits)[0] |= 1u;
174 }
set_has_target_node(HasBits * has_bits)175 static void set_has_target_node(HasBits* has_bits) {
176 (*has_bits)[0] |= 2u;
177 }
set_has_to_proc(HasBits * has_bits)178 static void set_has_to_proc(HasBits* has_bits) {
179 (*has_bits)[0] |= 4u;
180 }
set_has_to_thread(HasBits * has_bits)181 static void set_has_to_thread(HasBits* has_bits) {
182 (*has_bits)[0] |= 8u;
183 }
set_has_reply(HasBits * has_bits)184 static void set_has_reply(HasBits* has_bits) {
185 (*has_bits)[0] |= 16u;
186 }
set_has_code(HasBits * has_bits)187 static void set_has_code(HasBits* has_bits) {
188 (*has_bits)[0] |= 32u;
189 }
set_has_flags(HasBits * has_bits)190 static void set_has_flags(HasBits* has_bits) {
191 (*has_bits)[0] |= 64u;
192 }
193 };
194
BinderTransactionFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)195 BinderTransactionFtraceEvent::BinderTransactionFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
196 bool is_message_owned)
197 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
198 SharedCtor(arena, is_message_owned);
199 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderTransactionFtraceEvent)
200 }
BinderTransactionFtraceEvent(const BinderTransactionFtraceEvent & from)201 BinderTransactionFtraceEvent::BinderTransactionFtraceEvent(const BinderTransactionFtraceEvent& from)
202 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
203 BinderTransactionFtraceEvent* const _this = this; (void)_this;
204 new (&_impl_) Impl_{
205 decltype(_impl_._has_bits_){from._impl_._has_bits_}
206 , /*decltype(_impl_._cached_size_)*/{}
207 , decltype(_impl_.debug_id_){}
208 , decltype(_impl_.target_node_){}
209 , decltype(_impl_.to_proc_){}
210 , decltype(_impl_.to_thread_){}
211 , decltype(_impl_.reply_){}
212 , decltype(_impl_.code_){}
213 , decltype(_impl_.flags_){}};
214
215 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
216 ::memcpy(&_impl_.debug_id_, &from._impl_.debug_id_,
217 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.flags_) -
218 reinterpret_cast<char*>(&_impl_.debug_id_)) + sizeof(_impl_.flags_));
219 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderTransactionFtraceEvent)
220 }
221
SharedCtor(::_pb::Arena * arena,bool is_message_owned)222 inline void BinderTransactionFtraceEvent::SharedCtor(
223 ::_pb::Arena* arena, bool is_message_owned) {
224 (void)arena;
225 (void)is_message_owned;
226 new (&_impl_) Impl_{
227 decltype(_impl_._has_bits_){}
228 , /*decltype(_impl_._cached_size_)*/{}
229 , decltype(_impl_.debug_id_){0}
230 , decltype(_impl_.target_node_){0}
231 , decltype(_impl_.to_proc_){0}
232 , decltype(_impl_.to_thread_){0}
233 , decltype(_impl_.reply_){0}
234 , decltype(_impl_.code_){0u}
235 , decltype(_impl_.flags_){0u}
236 };
237 }
238
~BinderTransactionFtraceEvent()239 BinderTransactionFtraceEvent::~BinderTransactionFtraceEvent() {
240 // @@protoc_insertion_point(destructor:perfetto.protos.BinderTransactionFtraceEvent)
241 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
242 (void)arena;
243 return;
244 }
245 SharedDtor();
246 }
247
SharedDtor()248 inline void BinderTransactionFtraceEvent::SharedDtor() {
249 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
250 }
251
SetCachedSize(int size) const252 void BinderTransactionFtraceEvent::SetCachedSize(int size) const {
253 _impl_._cached_size_.Set(size);
254 }
255
Clear()256 void BinderTransactionFtraceEvent::Clear() {
257 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderTransactionFtraceEvent)
258 ::uint32_t cached_has_bits = 0;
259 // Prevent compiler warnings about cached_has_bits being unused
260 (void) cached_has_bits;
261
262 cached_has_bits = _impl_._has_bits_[0];
263 if (cached_has_bits & 0x0000007fu) {
264 ::memset(&_impl_.debug_id_, 0, static_cast<size_t>(
265 reinterpret_cast<char*>(&_impl_.flags_) -
266 reinterpret_cast<char*>(&_impl_.debug_id_)) + sizeof(_impl_.flags_));
267 }
268 _impl_._has_bits_.Clear();
269 _internal_metadata_.Clear<std::string>();
270 }
271
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)272 const char* BinderTransactionFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
273 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
274 _Internal::HasBits has_bits{};
275 while (!ctx->Done(&ptr)) {
276 ::uint32_t tag;
277 ptr = ::_pbi::ReadTag(ptr, &tag);
278 switch (tag >> 3) {
279 // optional int32 debug_id = 1;
280 case 1:
281 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
282 _Internal::set_has_debug_id(&has_bits);
283 _impl_.debug_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
284 CHK_(ptr);
285 } else {
286 goto handle_unusual;
287 }
288 continue;
289 // optional int32 target_node = 2;
290 case 2:
291 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
292 _Internal::set_has_target_node(&has_bits);
293 _impl_.target_node_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
294 CHK_(ptr);
295 } else {
296 goto handle_unusual;
297 }
298 continue;
299 // optional int32 to_proc = 3;
300 case 3:
301 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
302 _Internal::set_has_to_proc(&has_bits);
303 _impl_.to_proc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
304 CHK_(ptr);
305 } else {
306 goto handle_unusual;
307 }
308 continue;
309 // optional int32 to_thread = 4;
310 case 4:
311 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
312 _Internal::set_has_to_thread(&has_bits);
313 _impl_.to_thread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
314 CHK_(ptr);
315 } else {
316 goto handle_unusual;
317 }
318 continue;
319 // optional int32 reply = 5;
320 case 5:
321 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
322 _Internal::set_has_reply(&has_bits);
323 _impl_.reply_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
324 CHK_(ptr);
325 } else {
326 goto handle_unusual;
327 }
328 continue;
329 // optional uint32 code = 6;
330 case 6:
331 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
332 _Internal::set_has_code(&has_bits);
333 _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
334 CHK_(ptr);
335 } else {
336 goto handle_unusual;
337 }
338 continue;
339 // optional uint32 flags = 7;
340 case 7:
341 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
342 _Internal::set_has_flags(&has_bits);
343 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
344 CHK_(ptr);
345 } else {
346 goto handle_unusual;
347 }
348 continue;
349 default:
350 goto handle_unusual;
351 } // switch
352 handle_unusual:
353 if ((tag == 0) || ((tag & 7) == 4)) {
354 CHK_(ptr);
355 ctx->SetLastTag(tag);
356 goto message_done;
357 }
358 ptr = UnknownFieldParse(
359 tag,
360 _internal_metadata_.mutable_unknown_fields<std::string>(),
361 ptr, ctx);
362 CHK_(ptr != nullptr);
363 } // while
364 message_done:
365 _impl_._has_bits_.Or(has_bits);
366 return ptr;
367 failure:
368 ptr = nullptr;
369 goto message_done;
370 #undef CHK_
371 }
372
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const373 ::uint8_t* BinderTransactionFtraceEvent::_InternalSerialize(
374 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
375 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderTransactionFtraceEvent)
376 ::uint32_t cached_has_bits = 0;
377 (void) cached_has_bits;
378
379 cached_has_bits = _impl_._has_bits_[0];
380 // optional int32 debug_id = 1;
381 if (cached_has_bits & 0x00000001u) {
382 target = stream->EnsureSpace(target);
383 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_debug_id(), target);
384 }
385
386 // optional int32 target_node = 2;
387 if (cached_has_bits & 0x00000002u) {
388 target = stream->EnsureSpace(target);
389 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_target_node(), target);
390 }
391
392 // optional int32 to_proc = 3;
393 if (cached_has_bits & 0x00000004u) {
394 target = stream->EnsureSpace(target);
395 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_to_proc(), target);
396 }
397
398 // optional int32 to_thread = 4;
399 if (cached_has_bits & 0x00000008u) {
400 target = stream->EnsureSpace(target);
401 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_to_thread(), target);
402 }
403
404 // optional int32 reply = 5;
405 if (cached_has_bits & 0x00000010u) {
406 target = stream->EnsureSpace(target);
407 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_reply(), target);
408 }
409
410 // optional uint32 code = 6;
411 if (cached_has_bits & 0x00000020u) {
412 target = stream->EnsureSpace(target);
413 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_code(), target);
414 }
415
416 // optional uint32 flags = 7;
417 if (cached_has_bits & 0x00000040u) {
418 target = stream->EnsureSpace(target);
419 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_flags(), target);
420 }
421
422 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
423 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
424 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
425 }
426 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderTransactionFtraceEvent)
427 return target;
428 }
429
ByteSizeLong() const430 size_t BinderTransactionFtraceEvent::ByteSizeLong() const {
431 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderTransactionFtraceEvent)
432 size_t total_size = 0;
433
434 ::uint32_t cached_has_bits = 0;
435 // Prevent compiler warnings about cached_has_bits being unused
436 (void) cached_has_bits;
437
438 cached_has_bits = _impl_._has_bits_[0];
439 if (cached_has_bits & 0x0000007fu) {
440 // optional int32 debug_id = 1;
441 if (cached_has_bits & 0x00000001u) {
442 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_debug_id());
443 }
444
445 // optional int32 target_node = 2;
446 if (cached_has_bits & 0x00000002u) {
447 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_target_node());
448 }
449
450 // optional int32 to_proc = 3;
451 if (cached_has_bits & 0x00000004u) {
452 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_to_proc());
453 }
454
455 // optional int32 to_thread = 4;
456 if (cached_has_bits & 0x00000008u) {
457 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_to_thread());
458 }
459
460 // optional int32 reply = 5;
461 if (cached_has_bits & 0x00000010u) {
462 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_reply());
463 }
464
465 // optional uint32 code = 6;
466 if (cached_has_bits & 0x00000020u) {
467 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_code());
468 }
469
470 // optional uint32 flags = 7;
471 if (cached_has_bits & 0x00000040u) {
472 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
473 }
474
475 }
476 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
477 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
478 }
479 int cached_size = ::_pbi::ToCachedSize(total_size);
480 SetCachedSize(cached_size);
481 return total_size;
482 }
483
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)484 void BinderTransactionFtraceEvent::CheckTypeAndMergeFrom(
485 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
486 MergeFrom(*::_pbi::DownCast<const BinderTransactionFtraceEvent*>(
487 &from));
488 }
489
MergeFrom(const BinderTransactionFtraceEvent & from)490 void BinderTransactionFtraceEvent::MergeFrom(const BinderTransactionFtraceEvent& from) {
491 BinderTransactionFtraceEvent* const _this = this;
492 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderTransactionFtraceEvent)
493 GOOGLE_DCHECK_NE(&from, _this);
494 ::uint32_t cached_has_bits = 0;
495 (void) cached_has_bits;
496
497 cached_has_bits = from._impl_._has_bits_[0];
498 if (cached_has_bits & 0x0000007fu) {
499 if (cached_has_bits & 0x00000001u) {
500 _this->_impl_.debug_id_ = from._impl_.debug_id_;
501 }
502 if (cached_has_bits & 0x00000002u) {
503 _this->_impl_.target_node_ = from._impl_.target_node_;
504 }
505 if (cached_has_bits & 0x00000004u) {
506 _this->_impl_.to_proc_ = from._impl_.to_proc_;
507 }
508 if (cached_has_bits & 0x00000008u) {
509 _this->_impl_.to_thread_ = from._impl_.to_thread_;
510 }
511 if (cached_has_bits & 0x00000010u) {
512 _this->_impl_.reply_ = from._impl_.reply_;
513 }
514 if (cached_has_bits & 0x00000020u) {
515 _this->_impl_.code_ = from._impl_.code_;
516 }
517 if (cached_has_bits & 0x00000040u) {
518 _this->_impl_.flags_ = from._impl_.flags_;
519 }
520 _this->_impl_._has_bits_[0] |= cached_has_bits;
521 }
522 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
523 }
524
CopyFrom(const BinderTransactionFtraceEvent & from)525 void BinderTransactionFtraceEvent::CopyFrom(const BinderTransactionFtraceEvent& from) {
526 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderTransactionFtraceEvent)
527 if (&from == this) return;
528 Clear();
529 MergeFrom(from);
530 }
531
IsInitialized() const532 bool BinderTransactionFtraceEvent::IsInitialized() const {
533 return true;
534 }
535
InternalSwap(BinderTransactionFtraceEvent * other)536 void BinderTransactionFtraceEvent::InternalSwap(BinderTransactionFtraceEvent* other) {
537 using std::swap;
538 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
539 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
540 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
541 PROTOBUF_FIELD_OFFSET(BinderTransactionFtraceEvent, _impl_.flags_)
542 + sizeof(BinderTransactionFtraceEvent::_impl_.flags_) // NOLINT
543 - PROTOBUF_FIELD_OFFSET(BinderTransactionFtraceEvent, _impl_.debug_id_)>(
544 reinterpret_cast<char*>(&_impl_.debug_id_),
545 reinterpret_cast<char*>(&other->_impl_.debug_id_));
546 }
547
GetTypeName() const548 std::string BinderTransactionFtraceEvent::GetTypeName() const {
549 return "perfetto.protos.BinderTransactionFtraceEvent";
550 }
551
552
553 // ===================================================================
554
555 class BinderTransactionReceivedFtraceEvent::_Internal {
556 public:
557 using HasBits = decltype(std::declval<BinderTransactionReceivedFtraceEvent>()._impl_._has_bits_);
set_has_debug_id(HasBits * has_bits)558 static void set_has_debug_id(HasBits* has_bits) {
559 (*has_bits)[0] |= 1u;
560 }
561 };
562
BinderTransactionReceivedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)563 BinderTransactionReceivedFtraceEvent::BinderTransactionReceivedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
564 bool is_message_owned)
565 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
566 SharedCtor(arena, is_message_owned);
567 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderTransactionReceivedFtraceEvent)
568 }
BinderTransactionReceivedFtraceEvent(const BinderTransactionReceivedFtraceEvent & from)569 BinderTransactionReceivedFtraceEvent::BinderTransactionReceivedFtraceEvent(const BinderTransactionReceivedFtraceEvent& from)
570 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
571 BinderTransactionReceivedFtraceEvent* const _this = this; (void)_this;
572 new (&_impl_) Impl_{
573 decltype(_impl_._has_bits_){from._impl_._has_bits_}
574 , /*decltype(_impl_._cached_size_)*/{}
575 , decltype(_impl_.debug_id_){}};
576
577 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
578 _this->_impl_.debug_id_ = from._impl_.debug_id_;
579 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderTransactionReceivedFtraceEvent)
580 }
581
SharedCtor(::_pb::Arena * arena,bool is_message_owned)582 inline void BinderTransactionReceivedFtraceEvent::SharedCtor(
583 ::_pb::Arena* arena, bool is_message_owned) {
584 (void)arena;
585 (void)is_message_owned;
586 new (&_impl_) Impl_{
587 decltype(_impl_._has_bits_){}
588 , /*decltype(_impl_._cached_size_)*/{}
589 , decltype(_impl_.debug_id_){0}
590 };
591 }
592
~BinderTransactionReceivedFtraceEvent()593 BinderTransactionReceivedFtraceEvent::~BinderTransactionReceivedFtraceEvent() {
594 // @@protoc_insertion_point(destructor:perfetto.protos.BinderTransactionReceivedFtraceEvent)
595 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
596 (void)arena;
597 return;
598 }
599 SharedDtor();
600 }
601
SharedDtor()602 inline void BinderTransactionReceivedFtraceEvent::SharedDtor() {
603 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
604 }
605
SetCachedSize(int size) const606 void BinderTransactionReceivedFtraceEvent::SetCachedSize(int size) const {
607 _impl_._cached_size_.Set(size);
608 }
609
Clear()610 void BinderTransactionReceivedFtraceEvent::Clear() {
611 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderTransactionReceivedFtraceEvent)
612 ::uint32_t cached_has_bits = 0;
613 // Prevent compiler warnings about cached_has_bits being unused
614 (void) cached_has_bits;
615
616 _impl_.debug_id_ = 0;
617 _impl_._has_bits_.Clear();
618 _internal_metadata_.Clear<std::string>();
619 }
620
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)621 const char* BinderTransactionReceivedFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
622 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
623 _Internal::HasBits has_bits{};
624 while (!ctx->Done(&ptr)) {
625 ::uint32_t tag;
626 ptr = ::_pbi::ReadTag(ptr, &tag);
627 switch (tag >> 3) {
628 // optional int32 debug_id = 1;
629 case 1:
630 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
631 _Internal::set_has_debug_id(&has_bits);
632 _impl_.debug_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
633 CHK_(ptr);
634 } else {
635 goto handle_unusual;
636 }
637 continue;
638 default:
639 goto handle_unusual;
640 } // switch
641 handle_unusual:
642 if ((tag == 0) || ((tag & 7) == 4)) {
643 CHK_(ptr);
644 ctx->SetLastTag(tag);
645 goto message_done;
646 }
647 ptr = UnknownFieldParse(
648 tag,
649 _internal_metadata_.mutable_unknown_fields<std::string>(),
650 ptr, ctx);
651 CHK_(ptr != nullptr);
652 } // while
653 message_done:
654 _impl_._has_bits_.Or(has_bits);
655 return ptr;
656 failure:
657 ptr = nullptr;
658 goto message_done;
659 #undef CHK_
660 }
661
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const662 ::uint8_t* BinderTransactionReceivedFtraceEvent::_InternalSerialize(
663 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
664 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderTransactionReceivedFtraceEvent)
665 ::uint32_t cached_has_bits = 0;
666 (void) cached_has_bits;
667
668 cached_has_bits = _impl_._has_bits_[0];
669 // optional int32 debug_id = 1;
670 if (cached_has_bits & 0x00000001u) {
671 target = stream->EnsureSpace(target);
672 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_debug_id(), target);
673 }
674
675 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
676 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
677 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
678 }
679 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderTransactionReceivedFtraceEvent)
680 return target;
681 }
682
ByteSizeLong() const683 size_t BinderTransactionReceivedFtraceEvent::ByteSizeLong() const {
684 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderTransactionReceivedFtraceEvent)
685 size_t total_size = 0;
686
687 ::uint32_t cached_has_bits = 0;
688 // Prevent compiler warnings about cached_has_bits being unused
689 (void) cached_has_bits;
690
691 // optional int32 debug_id = 1;
692 cached_has_bits = _impl_._has_bits_[0];
693 if (cached_has_bits & 0x00000001u) {
694 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_debug_id());
695 }
696
697 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
698 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
699 }
700 int cached_size = ::_pbi::ToCachedSize(total_size);
701 SetCachedSize(cached_size);
702 return total_size;
703 }
704
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)705 void BinderTransactionReceivedFtraceEvent::CheckTypeAndMergeFrom(
706 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
707 MergeFrom(*::_pbi::DownCast<const BinderTransactionReceivedFtraceEvent*>(
708 &from));
709 }
710
MergeFrom(const BinderTransactionReceivedFtraceEvent & from)711 void BinderTransactionReceivedFtraceEvent::MergeFrom(const BinderTransactionReceivedFtraceEvent& from) {
712 BinderTransactionReceivedFtraceEvent* const _this = this;
713 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderTransactionReceivedFtraceEvent)
714 GOOGLE_DCHECK_NE(&from, _this);
715 ::uint32_t cached_has_bits = 0;
716 (void) cached_has_bits;
717
718 if (from._internal_has_debug_id()) {
719 _this->_internal_set_debug_id(from._internal_debug_id());
720 }
721 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
722 }
723
CopyFrom(const BinderTransactionReceivedFtraceEvent & from)724 void BinderTransactionReceivedFtraceEvent::CopyFrom(const BinderTransactionReceivedFtraceEvent& from) {
725 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderTransactionReceivedFtraceEvent)
726 if (&from == this) return;
727 Clear();
728 MergeFrom(from);
729 }
730
IsInitialized() const731 bool BinderTransactionReceivedFtraceEvent::IsInitialized() const {
732 return true;
733 }
734
InternalSwap(BinderTransactionReceivedFtraceEvent * other)735 void BinderTransactionReceivedFtraceEvent::InternalSwap(BinderTransactionReceivedFtraceEvent* other) {
736 using std::swap;
737 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
738 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
739 swap(_impl_.debug_id_, other->_impl_.debug_id_);
740 }
741
GetTypeName() const742 std::string BinderTransactionReceivedFtraceEvent::GetTypeName() const {
743 return "perfetto.protos.BinderTransactionReceivedFtraceEvent";
744 }
745
746
747 // ===================================================================
748
749 class BinderSetPriorityFtraceEvent::_Internal {
750 public:
751 using HasBits = decltype(std::declval<BinderSetPriorityFtraceEvent>()._impl_._has_bits_);
set_has_proc(HasBits * has_bits)752 static void set_has_proc(HasBits* has_bits) {
753 (*has_bits)[0] |= 1u;
754 }
set_has_thread(HasBits * has_bits)755 static void set_has_thread(HasBits* has_bits) {
756 (*has_bits)[0] |= 2u;
757 }
set_has_old_prio(HasBits * has_bits)758 static void set_has_old_prio(HasBits* has_bits) {
759 (*has_bits)[0] |= 4u;
760 }
set_has_new_prio(HasBits * has_bits)761 static void set_has_new_prio(HasBits* has_bits) {
762 (*has_bits)[0] |= 8u;
763 }
set_has_desired_prio(HasBits * has_bits)764 static void set_has_desired_prio(HasBits* has_bits) {
765 (*has_bits)[0] |= 16u;
766 }
767 };
768
BinderSetPriorityFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)769 BinderSetPriorityFtraceEvent::BinderSetPriorityFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
770 bool is_message_owned)
771 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
772 SharedCtor(arena, is_message_owned);
773 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderSetPriorityFtraceEvent)
774 }
BinderSetPriorityFtraceEvent(const BinderSetPriorityFtraceEvent & from)775 BinderSetPriorityFtraceEvent::BinderSetPriorityFtraceEvent(const BinderSetPriorityFtraceEvent& from)
776 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
777 BinderSetPriorityFtraceEvent* const _this = this; (void)_this;
778 new (&_impl_) Impl_{
779 decltype(_impl_._has_bits_){from._impl_._has_bits_}
780 , /*decltype(_impl_._cached_size_)*/{}
781 , decltype(_impl_.proc_){}
782 , decltype(_impl_.thread_){}
783 , decltype(_impl_.old_prio_){}
784 , decltype(_impl_.new_prio_){}
785 , decltype(_impl_.desired_prio_){}};
786
787 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
788 ::memcpy(&_impl_.proc_, &from._impl_.proc_,
789 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.desired_prio_) -
790 reinterpret_cast<char*>(&_impl_.proc_)) + sizeof(_impl_.desired_prio_));
791 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderSetPriorityFtraceEvent)
792 }
793
SharedCtor(::_pb::Arena * arena,bool is_message_owned)794 inline void BinderSetPriorityFtraceEvent::SharedCtor(
795 ::_pb::Arena* arena, bool is_message_owned) {
796 (void)arena;
797 (void)is_message_owned;
798 new (&_impl_) Impl_{
799 decltype(_impl_._has_bits_){}
800 , /*decltype(_impl_._cached_size_)*/{}
801 , decltype(_impl_.proc_){0}
802 , decltype(_impl_.thread_){0}
803 , decltype(_impl_.old_prio_){0u}
804 , decltype(_impl_.new_prio_){0u}
805 , decltype(_impl_.desired_prio_){0u}
806 };
807 }
808
~BinderSetPriorityFtraceEvent()809 BinderSetPriorityFtraceEvent::~BinderSetPriorityFtraceEvent() {
810 // @@protoc_insertion_point(destructor:perfetto.protos.BinderSetPriorityFtraceEvent)
811 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
812 (void)arena;
813 return;
814 }
815 SharedDtor();
816 }
817
SharedDtor()818 inline void BinderSetPriorityFtraceEvent::SharedDtor() {
819 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
820 }
821
SetCachedSize(int size) const822 void BinderSetPriorityFtraceEvent::SetCachedSize(int size) const {
823 _impl_._cached_size_.Set(size);
824 }
825
Clear()826 void BinderSetPriorityFtraceEvent::Clear() {
827 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderSetPriorityFtraceEvent)
828 ::uint32_t cached_has_bits = 0;
829 // Prevent compiler warnings about cached_has_bits being unused
830 (void) cached_has_bits;
831
832 cached_has_bits = _impl_._has_bits_[0];
833 if (cached_has_bits & 0x0000001fu) {
834 ::memset(&_impl_.proc_, 0, static_cast<size_t>(
835 reinterpret_cast<char*>(&_impl_.desired_prio_) -
836 reinterpret_cast<char*>(&_impl_.proc_)) + sizeof(_impl_.desired_prio_));
837 }
838 _impl_._has_bits_.Clear();
839 _internal_metadata_.Clear<std::string>();
840 }
841
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)842 const char* BinderSetPriorityFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
843 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
844 _Internal::HasBits has_bits{};
845 while (!ctx->Done(&ptr)) {
846 ::uint32_t tag;
847 ptr = ::_pbi::ReadTag(ptr, &tag);
848 switch (tag >> 3) {
849 // optional int32 proc = 1;
850 case 1:
851 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
852 _Internal::set_has_proc(&has_bits);
853 _impl_.proc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
854 CHK_(ptr);
855 } else {
856 goto handle_unusual;
857 }
858 continue;
859 // optional int32 thread = 2;
860 case 2:
861 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
862 _Internal::set_has_thread(&has_bits);
863 _impl_.thread_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
864 CHK_(ptr);
865 } else {
866 goto handle_unusual;
867 }
868 continue;
869 // optional uint32 old_prio = 3;
870 case 3:
871 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
872 _Internal::set_has_old_prio(&has_bits);
873 _impl_.old_prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
874 CHK_(ptr);
875 } else {
876 goto handle_unusual;
877 }
878 continue;
879 // optional uint32 new_prio = 4;
880 case 4:
881 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
882 _Internal::set_has_new_prio(&has_bits);
883 _impl_.new_prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
884 CHK_(ptr);
885 } else {
886 goto handle_unusual;
887 }
888 continue;
889 // optional uint32 desired_prio = 5;
890 case 5:
891 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
892 _Internal::set_has_desired_prio(&has_bits);
893 _impl_.desired_prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
894 CHK_(ptr);
895 } else {
896 goto handle_unusual;
897 }
898 continue;
899 default:
900 goto handle_unusual;
901 } // switch
902 handle_unusual:
903 if ((tag == 0) || ((tag & 7) == 4)) {
904 CHK_(ptr);
905 ctx->SetLastTag(tag);
906 goto message_done;
907 }
908 ptr = UnknownFieldParse(
909 tag,
910 _internal_metadata_.mutable_unknown_fields<std::string>(),
911 ptr, ctx);
912 CHK_(ptr != nullptr);
913 } // while
914 message_done:
915 _impl_._has_bits_.Or(has_bits);
916 return ptr;
917 failure:
918 ptr = nullptr;
919 goto message_done;
920 #undef CHK_
921 }
922
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const923 ::uint8_t* BinderSetPriorityFtraceEvent::_InternalSerialize(
924 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
925 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderSetPriorityFtraceEvent)
926 ::uint32_t cached_has_bits = 0;
927 (void) cached_has_bits;
928
929 cached_has_bits = _impl_._has_bits_[0];
930 // optional int32 proc = 1;
931 if (cached_has_bits & 0x00000001u) {
932 target = stream->EnsureSpace(target);
933 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_proc(), target);
934 }
935
936 // optional int32 thread = 2;
937 if (cached_has_bits & 0x00000002u) {
938 target = stream->EnsureSpace(target);
939 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_thread(), target);
940 }
941
942 // optional uint32 old_prio = 3;
943 if (cached_has_bits & 0x00000004u) {
944 target = stream->EnsureSpace(target);
945 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_old_prio(), target);
946 }
947
948 // optional uint32 new_prio = 4;
949 if (cached_has_bits & 0x00000008u) {
950 target = stream->EnsureSpace(target);
951 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_new_prio(), target);
952 }
953
954 // optional uint32 desired_prio = 5;
955 if (cached_has_bits & 0x00000010u) {
956 target = stream->EnsureSpace(target);
957 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_desired_prio(), target);
958 }
959
960 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
961 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
962 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
963 }
964 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderSetPriorityFtraceEvent)
965 return target;
966 }
967
ByteSizeLong() const968 size_t BinderSetPriorityFtraceEvent::ByteSizeLong() const {
969 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderSetPriorityFtraceEvent)
970 size_t total_size = 0;
971
972 ::uint32_t cached_has_bits = 0;
973 // Prevent compiler warnings about cached_has_bits being unused
974 (void) cached_has_bits;
975
976 cached_has_bits = _impl_._has_bits_[0];
977 if (cached_has_bits & 0x0000001fu) {
978 // optional int32 proc = 1;
979 if (cached_has_bits & 0x00000001u) {
980 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_proc());
981 }
982
983 // optional int32 thread = 2;
984 if (cached_has_bits & 0x00000002u) {
985 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_thread());
986 }
987
988 // optional uint32 old_prio = 3;
989 if (cached_has_bits & 0x00000004u) {
990 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_old_prio());
991 }
992
993 // optional uint32 new_prio = 4;
994 if (cached_has_bits & 0x00000008u) {
995 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_new_prio());
996 }
997
998 // optional uint32 desired_prio = 5;
999 if (cached_has_bits & 0x00000010u) {
1000 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_desired_prio());
1001 }
1002
1003 }
1004 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1005 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1006 }
1007 int cached_size = ::_pbi::ToCachedSize(total_size);
1008 SetCachedSize(cached_size);
1009 return total_size;
1010 }
1011
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1012 void BinderSetPriorityFtraceEvent::CheckTypeAndMergeFrom(
1013 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1014 MergeFrom(*::_pbi::DownCast<const BinderSetPriorityFtraceEvent*>(
1015 &from));
1016 }
1017
MergeFrom(const BinderSetPriorityFtraceEvent & from)1018 void BinderSetPriorityFtraceEvent::MergeFrom(const BinderSetPriorityFtraceEvent& from) {
1019 BinderSetPriorityFtraceEvent* const _this = this;
1020 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderSetPriorityFtraceEvent)
1021 GOOGLE_DCHECK_NE(&from, _this);
1022 ::uint32_t cached_has_bits = 0;
1023 (void) cached_has_bits;
1024
1025 cached_has_bits = from._impl_._has_bits_[0];
1026 if (cached_has_bits & 0x0000001fu) {
1027 if (cached_has_bits & 0x00000001u) {
1028 _this->_impl_.proc_ = from._impl_.proc_;
1029 }
1030 if (cached_has_bits & 0x00000002u) {
1031 _this->_impl_.thread_ = from._impl_.thread_;
1032 }
1033 if (cached_has_bits & 0x00000004u) {
1034 _this->_impl_.old_prio_ = from._impl_.old_prio_;
1035 }
1036 if (cached_has_bits & 0x00000008u) {
1037 _this->_impl_.new_prio_ = from._impl_.new_prio_;
1038 }
1039 if (cached_has_bits & 0x00000010u) {
1040 _this->_impl_.desired_prio_ = from._impl_.desired_prio_;
1041 }
1042 _this->_impl_._has_bits_[0] |= cached_has_bits;
1043 }
1044 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1045 }
1046
CopyFrom(const BinderSetPriorityFtraceEvent & from)1047 void BinderSetPriorityFtraceEvent::CopyFrom(const BinderSetPriorityFtraceEvent& from) {
1048 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderSetPriorityFtraceEvent)
1049 if (&from == this) return;
1050 Clear();
1051 MergeFrom(from);
1052 }
1053
IsInitialized() const1054 bool BinderSetPriorityFtraceEvent::IsInitialized() const {
1055 return true;
1056 }
1057
InternalSwap(BinderSetPriorityFtraceEvent * other)1058 void BinderSetPriorityFtraceEvent::InternalSwap(BinderSetPriorityFtraceEvent* other) {
1059 using std::swap;
1060 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1061 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1062 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1063 PROTOBUF_FIELD_OFFSET(BinderSetPriorityFtraceEvent, _impl_.desired_prio_)
1064 + sizeof(BinderSetPriorityFtraceEvent::_impl_.desired_prio_) // NOLINT
1065 - PROTOBUF_FIELD_OFFSET(BinderSetPriorityFtraceEvent, _impl_.proc_)>(
1066 reinterpret_cast<char*>(&_impl_.proc_),
1067 reinterpret_cast<char*>(&other->_impl_.proc_));
1068 }
1069
GetTypeName() const1070 std::string BinderSetPriorityFtraceEvent::GetTypeName() const {
1071 return "perfetto.protos.BinderSetPriorityFtraceEvent";
1072 }
1073
1074
1075 // ===================================================================
1076
1077 class BinderLockFtraceEvent::_Internal {
1078 public:
1079 using HasBits = decltype(std::declval<BinderLockFtraceEvent>()._impl_._has_bits_);
set_has_tag(HasBits * has_bits)1080 static void set_has_tag(HasBits* has_bits) {
1081 (*has_bits)[0] |= 1u;
1082 }
1083 };
1084
BinderLockFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1085 BinderLockFtraceEvent::BinderLockFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1086 bool is_message_owned)
1087 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1088 SharedCtor(arena, is_message_owned);
1089 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderLockFtraceEvent)
1090 }
BinderLockFtraceEvent(const BinderLockFtraceEvent & from)1091 BinderLockFtraceEvent::BinderLockFtraceEvent(const BinderLockFtraceEvent& from)
1092 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1093 BinderLockFtraceEvent* const _this = this; (void)_this;
1094 new (&_impl_) Impl_{
1095 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1096 , /*decltype(_impl_._cached_size_)*/{}
1097 , decltype(_impl_.tag_){}};
1098
1099 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1100 _impl_.tag_.InitDefault();
1101 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1102 _impl_.tag_.Set("", GetArenaForAllocation());
1103 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1104 if (from._internal_has_tag()) {
1105 _this->_impl_.tag_.Set(from._internal_tag(),
1106 _this->GetArenaForAllocation());
1107 }
1108 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderLockFtraceEvent)
1109 }
1110
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1111 inline void BinderLockFtraceEvent::SharedCtor(
1112 ::_pb::Arena* arena, bool is_message_owned) {
1113 (void)arena;
1114 (void)is_message_owned;
1115 new (&_impl_) Impl_{
1116 decltype(_impl_._has_bits_){}
1117 , /*decltype(_impl_._cached_size_)*/{}
1118 , decltype(_impl_.tag_){}
1119 };
1120 _impl_.tag_.InitDefault();
1121 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1122 _impl_.tag_.Set("", GetArenaForAllocation());
1123 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1124 }
1125
~BinderLockFtraceEvent()1126 BinderLockFtraceEvent::~BinderLockFtraceEvent() {
1127 // @@protoc_insertion_point(destructor:perfetto.protos.BinderLockFtraceEvent)
1128 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1129 (void)arena;
1130 return;
1131 }
1132 SharedDtor();
1133 }
1134
SharedDtor()1135 inline void BinderLockFtraceEvent::SharedDtor() {
1136 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1137 _impl_.tag_.Destroy();
1138 }
1139
SetCachedSize(int size) const1140 void BinderLockFtraceEvent::SetCachedSize(int size) const {
1141 _impl_._cached_size_.Set(size);
1142 }
1143
Clear()1144 void BinderLockFtraceEvent::Clear() {
1145 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderLockFtraceEvent)
1146 ::uint32_t cached_has_bits = 0;
1147 // Prevent compiler warnings about cached_has_bits being unused
1148 (void) cached_has_bits;
1149
1150 cached_has_bits = _impl_._has_bits_[0];
1151 if (cached_has_bits & 0x00000001u) {
1152 _impl_.tag_.ClearNonDefaultToEmpty();
1153 }
1154 _impl_._has_bits_.Clear();
1155 _internal_metadata_.Clear<std::string>();
1156 }
1157
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1158 const char* BinderLockFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1159 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1160 _Internal::HasBits has_bits{};
1161 while (!ctx->Done(&ptr)) {
1162 ::uint32_t tag;
1163 ptr = ::_pbi::ReadTag(ptr, &tag);
1164 switch (tag >> 3) {
1165 // optional string tag = 1;
1166 case 1:
1167 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1168 auto str = _internal_mutable_tag();
1169 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1170 CHK_(ptr);
1171 } else {
1172 goto handle_unusual;
1173 }
1174 continue;
1175 default:
1176 goto handle_unusual;
1177 } // switch
1178 handle_unusual:
1179 if ((tag == 0) || ((tag & 7) == 4)) {
1180 CHK_(ptr);
1181 ctx->SetLastTag(tag);
1182 goto message_done;
1183 }
1184 ptr = UnknownFieldParse(
1185 tag,
1186 _internal_metadata_.mutable_unknown_fields<std::string>(),
1187 ptr, ctx);
1188 CHK_(ptr != nullptr);
1189 } // while
1190 message_done:
1191 _impl_._has_bits_.Or(has_bits);
1192 return ptr;
1193 failure:
1194 ptr = nullptr;
1195 goto message_done;
1196 #undef CHK_
1197 }
1198
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1199 ::uint8_t* BinderLockFtraceEvent::_InternalSerialize(
1200 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1201 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderLockFtraceEvent)
1202 ::uint32_t cached_has_bits = 0;
1203 (void) cached_has_bits;
1204
1205 cached_has_bits = _impl_._has_bits_[0];
1206 // optional string tag = 1;
1207 if (cached_has_bits & 0x00000001u) {
1208 target = stream->WriteStringMaybeAliased(
1209 1, this->_internal_tag(), target);
1210 }
1211
1212 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1213 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1214 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1215 }
1216 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderLockFtraceEvent)
1217 return target;
1218 }
1219
ByteSizeLong() const1220 size_t BinderLockFtraceEvent::ByteSizeLong() const {
1221 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderLockFtraceEvent)
1222 size_t total_size = 0;
1223
1224 ::uint32_t cached_has_bits = 0;
1225 // Prevent compiler warnings about cached_has_bits being unused
1226 (void) cached_has_bits;
1227
1228 // optional string tag = 1;
1229 cached_has_bits = _impl_._has_bits_[0];
1230 if (cached_has_bits & 0x00000001u) {
1231 total_size += 1 +
1232 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1233 this->_internal_tag());
1234 }
1235
1236 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1237 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1238 }
1239 int cached_size = ::_pbi::ToCachedSize(total_size);
1240 SetCachedSize(cached_size);
1241 return total_size;
1242 }
1243
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1244 void BinderLockFtraceEvent::CheckTypeAndMergeFrom(
1245 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1246 MergeFrom(*::_pbi::DownCast<const BinderLockFtraceEvent*>(
1247 &from));
1248 }
1249
MergeFrom(const BinderLockFtraceEvent & from)1250 void BinderLockFtraceEvent::MergeFrom(const BinderLockFtraceEvent& from) {
1251 BinderLockFtraceEvent* const _this = this;
1252 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderLockFtraceEvent)
1253 GOOGLE_DCHECK_NE(&from, _this);
1254 ::uint32_t cached_has_bits = 0;
1255 (void) cached_has_bits;
1256
1257 if (from._internal_has_tag()) {
1258 _this->_internal_set_tag(from._internal_tag());
1259 }
1260 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1261 }
1262
CopyFrom(const BinderLockFtraceEvent & from)1263 void BinderLockFtraceEvent::CopyFrom(const BinderLockFtraceEvent& from) {
1264 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderLockFtraceEvent)
1265 if (&from == this) return;
1266 Clear();
1267 MergeFrom(from);
1268 }
1269
IsInitialized() const1270 bool BinderLockFtraceEvent::IsInitialized() const {
1271 return true;
1272 }
1273
InternalSwap(BinderLockFtraceEvent * other)1274 void BinderLockFtraceEvent::InternalSwap(BinderLockFtraceEvent* other) {
1275 using std::swap;
1276 auto* lhs_arena = GetArenaForAllocation();
1277 auto* rhs_arena = other->GetArenaForAllocation();
1278 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1279 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1280 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1281 &_impl_.tag_, lhs_arena,
1282 &other->_impl_.tag_, rhs_arena
1283 );
1284 }
1285
GetTypeName() const1286 std::string BinderLockFtraceEvent::GetTypeName() const {
1287 return "perfetto.protos.BinderLockFtraceEvent";
1288 }
1289
1290
1291 // ===================================================================
1292
1293 class BinderLockedFtraceEvent::_Internal {
1294 public:
1295 using HasBits = decltype(std::declval<BinderLockedFtraceEvent>()._impl_._has_bits_);
set_has_tag(HasBits * has_bits)1296 static void set_has_tag(HasBits* has_bits) {
1297 (*has_bits)[0] |= 1u;
1298 }
1299 };
1300
BinderLockedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1301 BinderLockedFtraceEvent::BinderLockedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1302 bool is_message_owned)
1303 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1304 SharedCtor(arena, is_message_owned);
1305 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderLockedFtraceEvent)
1306 }
BinderLockedFtraceEvent(const BinderLockedFtraceEvent & from)1307 BinderLockedFtraceEvent::BinderLockedFtraceEvent(const BinderLockedFtraceEvent& from)
1308 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1309 BinderLockedFtraceEvent* const _this = this; (void)_this;
1310 new (&_impl_) Impl_{
1311 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1312 , /*decltype(_impl_._cached_size_)*/{}
1313 , decltype(_impl_.tag_){}};
1314
1315 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1316 _impl_.tag_.InitDefault();
1317 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1318 _impl_.tag_.Set("", GetArenaForAllocation());
1319 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1320 if (from._internal_has_tag()) {
1321 _this->_impl_.tag_.Set(from._internal_tag(),
1322 _this->GetArenaForAllocation());
1323 }
1324 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderLockedFtraceEvent)
1325 }
1326
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1327 inline void BinderLockedFtraceEvent::SharedCtor(
1328 ::_pb::Arena* arena, bool is_message_owned) {
1329 (void)arena;
1330 (void)is_message_owned;
1331 new (&_impl_) Impl_{
1332 decltype(_impl_._has_bits_){}
1333 , /*decltype(_impl_._cached_size_)*/{}
1334 , decltype(_impl_.tag_){}
1335 };
1336 _impl_.tag_.InitDefault();
1337 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1338 _impl_.tag_.Set("", GetArenaForAllocation());
1339 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1340 }
1341
~BinderLockedFtraceEvent()1342 BinderLockedFtraceEvent::~BinderLockedFtraceEvent() {
1343 // @@protoc_insertion_point(destructor:perfetto.protos.BinderLockedFtraceEvent)
1344 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1345 (void)arena;
1346 return;
1347 }
1348 SharedDtor();
1349 }
1350
SharedDtor()1351 inline void BinderLockedFtraceEvent::SharedDtor() {
1352 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1353 _impl_.tag_.Destroy();
1354 }
1355
SetCachedSize(int size) const1356 void BinderLockedFtraceEvent::SetCachedSize(int size) const {
1357 _impl_._cached_size_.Set(size);
1358 }
1359
Clear()1360 void BinderLockedFtraceEvent::Clear() {
1361 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderLockedFtraceEvent)
1362 ::uint32_t cached_has_bits = 0;
1363 // Prevent compiler warnings about cached_has_bits being unused
1364 (void) cached_has_bits;
1365
1366 cached_has_bits = _impl_._has_bits_[0];
1367 if (cached_has_bits & 0x00000001u) {
1368 _impl_.tag_.ClearNonDefaultToEmpty();
1369 }
1370 _impl_._has_bits_.Clear();
1371 _internal_metadata_.Clear<std::string>();
1372 }
1373
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1374 const char* BinderLockedFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1375 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1376 _Internal::HasBits has_bits{};
1377 while (!ctx->Done(&ptr)) {
1378 ::uint32_t tag;
1379 ptr = ::_pbi::ReadTag(ptr, &tag);
1380 switch (tag >> 3) {
1381 // optional string tag = 1;
1382 case 1:
1383 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1384 auto str = _internal_mutable_tag();
1385 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1386 CHK_(ptr);
1387 } else {
1388 goto handle_unusual;
1389 }
1390 continue;
1391 default:
1392 goto handle_unusual;
1393 } // switch
1394 handle_unusual:
1395 if ((tag == 0) || ((tag & 7) == 4)) {
1396 CHK_(ptr);
1397 ctx->SetLastTag(tag);
1398 goto message_done;
1399 }
1400 ptr = UnknownFieldParse(
1401 tag,
1402 _internal_metadata_.mutable_unknown_fields<std::string>(),
1403 ptr, ctx);
1404 CHK_(ptr != nullptr);
1405 } // while
1406 message_done:
1407 _impl_._has_bits_.Or(has_bits);
1408 return ptr;
1409 failure:
1410 ptr = nullptr;
1411 goto message_done;
1412 #undef CHK_
1413 }
1414
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1415 ::uint8_t* BinderLockedFtraceEvent::_InternalSerialize(
1416 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1417 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderLockedFtraceEvent)
1418 ::uint32_t cached_has_bits = 0;
1419 (void) cached_has_bits;
1420
1421 cached_has_bits = _impl_._has_bits_[0];
1422 // optional string tag = 1;
1423 if (cached_has_bits & 0x00000001u) {
1424 target = stream->WriteStringMaybeAliased(
1425 1, this->_internal_tag(), target);
1426 }
1427
1428 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1429 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1430 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1431 }
1432 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderLockedFtraceEvent)
1433 return target;
1434 }
1435
ByteSizeLong() const1436 size_t BinderLockedFtraceEvent::ByteSizeLong() const {
1437 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderLockedFtraceEvent)
1438 size_t total_size = 0;
1439
1440 ::uint32_t cached_has_bits = 0;
1441 // Prevent compiler warnings about cached_has_bits being unused
1442 (void) cached_has_bits;
1443
1444 // optional string tag = 1;
1445 cached_has_bits = _impl_._has_bits_[0];
1446 if (cached_has_bits & 0x00000001u) {
1447 total_size += 1 +
1448 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1449 this->_internal_tag());
1450 }
1451
1452 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1453 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1454 }
1455 int cached_size = ::_pbi::ToCachedSize(total_size);
1456 SetCachedSize(cached_size);
1457 return total_size;
1458 }
1459
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1460 void BinderLockedFtraceEvent::CheckTypeAndMergeFrom(
1461 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1462 MergeFrom(*::_pbi::DownCast<const BinderLockedFtraceEvent*>(
1463 &from));
1464 }
1465
MergeFrom(const BinderLockedFtraceEvent & from)1466 void BinderLockedFtraceEvent::MergeFrom(const BinderLockedFtraceEvent& from) {
1467 BinderLockedFtraceEvent* const _this = this;
1468 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderLockedFtraceEvent)
1469 GOOGLE_DCHECK_NE(&from, _this);
1470 ::uint32_t cached_has_bits = 0;
1471 (void) cached_has_bits;
1472
1473 if (from._internal_has_tag()) {
1474 _this->_internal_set_tag(from._internal_tag());
1475 }
1476 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1477 }
1478
CopyFrom(const BinderLockedFtraceEvent & from)1479 void BinderLockedFtraceEvent::CopyFrom(const BinderLockedFtraceEvent& from) {
1480 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderLockedFtraceEvent)
1481 if (&from == this) return;
1482 Clear();
1483 MergeFrom(from);
1484 }
1485
IsInitialized() const1486 bool BinderLockedFtraceEvent::IsInitialized() const {
1487 return true;
1488 }
1489
InternalSwap(BinderLockedFtraceEvent * other)1490 void BinderLockedFtraceEvent::InternalSwap(BinderLockedFtraceEvent* other) {
1491 using std::swap;
1492 auto* lhs_arena = GetArenaForAllocation();
1493 auto* rhs_arena = other->GetArenaForAllocation();
1494 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1495 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1496 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1497 &_impl_.tag_, lhs_arena,
1498 &other->_impl_.tag_, rhs_arena
1499 );
1500 }
1501
GetTypeName() const1502 std::string BinderLockedFtraceEvent::GetTypeName() const {
1503 return "perfetto.protos.BinderLockedFtraceEvent";
1504 }
1505
1506
1507 // ===================================================================
1508
1509 class BinderUnlockFtraceEvent::_Internal {
1510 public:
1511 using HasBits = decltype(std::declval<BinderUnlockFtraceEvent>()._impl_._has_bits_);
set_has_tag(HasBits * has_bits)1512 static void set_has_tag(HasBits* has_bits) {
1513 (*has_bits)[0] |= 1u;
1514 }
1515 };
1516
BinderUnlockFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1517 BinderUnlockFtraceEvent::BinderUnlockFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1518 bool is_message_owned)
1519 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1520 SharedCtor(arena, is_message_owned);
1521 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderUnlockFtraceEvent)
1522 }
BinderUnlockFtraceEvent(const BinderUnlockFtraceEvent & from)1523 BinderUnlockFtraceEvent::BinderUnlockFtraceEvent(const BinderUnlockFtraceEvent& from)
1524 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1525 BinderUnlockFtraceEvent* const _this = this; (void)_this;
1526 new (&_impl_) Impl_{
1527 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1528 , /*decltype(_impl_._cached_size_)*/{}
1529 , decltype(_impl_.tag_){}};
1530
1531 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1532 _impl_.tag_.InitDefault();
1533 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1534 _impl_.tag_.Set("", GetArenaForAllocation());
1535 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1536 if (from._internal_has_tag()) {
1537 _this->_impl_.tag_.Set(from._internal_tag(),
1538 _this->GetArenaForAllocation());
1539 }
1540 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderUnlockFtraceEvent)
1541 }
1542
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1543 inline void BinderUnlockFtraceEvent::SharedCtor(
1544 ::_pb::Arena* arena, bool is_message_owned) {
1545 (void)arena;
1546 (void)is_message_owned;
1547 new (&_impl_) Impl_{
1548 decltype(_impl_._has_bits_){}
1549 , /*decltype(_impl_._cached_size_)*/{}
1550 , decltype(_impl_.tag_){}
1551 };
1552 _impl_.tag_.InitDefault();
1553 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1554 _impl_.tag_.Set("", GetArenaForAllocation());
1555 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1556 }
1557
~BinderUnlockFtraceEvent()1558 BinderUnlockFtraceEvent::~BinderUnlockFtraceEvent() {
1559 // @@protoc_insertion_point(destructor:perfetto.protos.BinderUnlockFtraceEvent)
1560 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1561 (void)arena;
1562 return;
1563 }
1564 SharedDtor();
1565 }
1566
SharedDtor()1567 inline void BinderUnlockFtraceEvent::SharedDtor() {
1568 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1569 _impl_.tag_.Destroy();
1570 }
1571
SetCachedSize(int size) const1572 void BinderUnlockFtraceEvent::SetCachedSize(int size) const {
1573 _impl_._cached_size_.Set(size);
1574 }
1575
Clear()1576 void BinderUnlockFtraceEvent::Clear() {
1577 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderUnlockFtraceEvent)
1578 ::uint32_t cached_has_bits = 0;
1579 // Prevent compiler warnings about cached_has_bits being unused
1580 (void) cached_has_bits;
1581
1582 cached_has_bits = _impl_._has_bits_[0];
1583 if (cached_has_bits & 0x00000001u) {
1584 _impl_.tag_.ClearNonDefaultToEmpty();
1585 }
1586 _impl_._has_bits_.Clear();
1587 _internal_metadata_.Clear<std::string>();
1588 }
1589
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1590 const char* BinderUnlockFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1591 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1592 _Internal::HasBits has_bits{};
1593 while (!ctx->Done(&ptr)) {
1594 ::uint32_t tag;
1595 ptr = ::_pbi::ReadTag(ptr, &tag);
1596 switch (tag >> 3) {
1597 // optional string tag = 1;
1598 case 1:
1599 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1600 auto str = _internal_mutable_tag();
1601 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1602 CHK_(ptr);
1603 } else {
1604 goto handle_unusual;
1605 }
1606 continue;
1607 default:
1608 goto handle_unusual;
1609 } // switch
1610 handle_unusual:
1611 if ((tag == 0) || ((tag & 7) == 4)) {
1612 CHK_(ptr);
1613 ctx->SetLastTag(tag);
1614 goto message_done;
1615 }
1616 ptr = UnknownFieldParse(
1617 tag,
1618 _internal_metadata_.mutable_unknown_fields<std::string>(),
1619 ptr, ctx);
1620 CHK_(ptr != nullptr);
1621 } // while
1622 message_done:
1623 _impl_._has_bits_.Or(has_bits);
1624 return ptr;
1625 failure:
1626 ptr = nullptr;
1627 goto message_done;
1628 #undef CHK_
1629 }
1630
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1631 ::uint8_t* BinderUnlockFtraceEvent::_InternalSerialize(
1632 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1633 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderUnlockFtraceEvent)
1634 ::uint32_t cached_has_bits = 0;
1635 (void) cached_has_bits;
1636
1637 cached_has_bits = _impl_._has_bits_[0];
1638 // optional string tag = 1;
1639 if (cached_has_bits & 0x00000001u) {
1640 target = stream->WriteStringMaybeAliased(
1641 1, this->_internal_tag(), target);
1642 }
1643
1644 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1645 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1646 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1647 }
1648 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderUnlockFtraceEvent)
1649 return target;
1650 }
1651
ByteSizeLong() const1652 size_t BinderUnlockFtraceEvent::ByteSizeLong() const {
1653 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderUnlockFtraceEvent)
1654 size_t total_size = 0;
1655
1656 ::uint32_t cached_has_bits = 0;
1657 // Prevent compiler warnings about cached_has_bits being unused
1658 (void) cached_has_bits;
1659
1660 // optional string tag = 1;
1661 cached_has_bits = _impl_._has_bits_[0];
1662 if (cached_has_bits & 0x00000001u) {
1663 total_size += 1 +
1664 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1665 this->_internal_tag());
1666 }
1667
1668 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1669 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1670 }
1671 int cached_size = ::_pbi::ToCachedSize(total_size);
1672 SetCachedSize(cached_size);
1673 return total_size;
1674 }
1675
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1676 void BinderUnlockFtraceEvent::CheckTypeAndMergeFrom(
1677 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1678 MergeFrom(*::_pbi::DownCast<const BinderUnlockFtraceEvent*>(
1679 &from));
1680 }
1681
MergeFrom(const BinderUnlockFtraceEvent & from)1682 void BinderUnlockFtraceEvent::MergeFrom(const BinderUnlockFtraceEvent& from) {
1683 BinderUnlockFtraceEvent* const _this = this;
1684 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderUnlockFtraceEvent)
1685 GOOGLE_DCHECK_NE(&from, _this);
1686 ::uint32_t cached_has_bits = 0;
1687 (void) cached_has_bits;
1688
1689 if (from._internal_has_tag()) {
1690 _this->_internal_set_tag(from._internal_tag());
1691 }
1692 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1693 }
1694
CopyFrom(const BinderUnlockFtraceEvent & from)1695 void BinderUnlockFtraceEvent::CopyFrom(const BinderUnlockFtraceEvent& from) {
1696 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderUnlockFtraceEvent)
1697 if (&from == this) return;
1698 Clear();
1699 MergeFrom(from);
1700 }
1701
IsInitialized() const1702 bool BinderUnlockFtraceEvent::IsInitialized() const {
1703 return true;
1704 }
1705
InternalSwap(BinderUnlockFtraceEvent * other)1706 void BinderUnlockFtraceEvent::InternalSwap(BinderUnlockFtraceEvent* other) {
1707 using std::swap;
1708 auto* lhs_arena = GetArenaForAllocation();
1709 auto* rhs_arena = other->GetArenaForAllocation();
1710 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1711 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1712 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1713 &_impl_.tag_, lhs_arena,
1714 &other->_impl_.tag_, rhs_arena
1715 );
1716 }
1717
GetTypeName() const1718 std::string BinderUnlockFtraceEvent::GetTypeName() const {
1719 return "perfetto.protos.BinderUnlockFtraceEvent";
1720 }
1721
1722
1723 // ===================================================================
1724
1725 class BinderTransactionAllocBufFtraceEvent::_Internal {
1726 public:
1727 using HasBits = decltype(std::declval<BinderTransactionAllocBufFtraceEvent>()._impl_._has_bits_);
set_has_data_size(HasBits * has_bits)1728 static void set_has_data_size(HasBits* has_bits) {
1729 (*has_bits)[0] |= 1u;
1730 }
set_has_debug_id(HasBits * has_bits)1731 static void set_has_debug_id(HasBits* has_bits) {
1732 (*has_bits)[0] |= 8u;
1733 }
set_has_offsets_size(HasBits * has_bits)1734 static void set_has_offsets_size(HasBits* has_bits) {
1735 (*has_bits)[0] |= 2u;
1736 }
set_has_extra_buffers_size(HasBits * has_bits)1737 static void set_has_extra_buffers_size(HasBits* has_bits) {
1738 (*has_bits)[0] |= 4u;
1739 }
1740 };
1741
BinderTransactionAllocBufFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1742 BinderTransactionAllocBufFtraceEvent::BinderTransactionAllocBufFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1743 bool is_message_owned)
1744 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1745 SharedCtor(arena, is_message_owned);
1746 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1747 }
BinderTransactionAllocBufFtraceEvent(const BinderTransactionAllocBufFtraceEvent & from)1748 BinderTransactionAllocBufFtraceEvent::BinderTransactionAllocBufFtraceEvent(const BinderTransactionAllocBufFtraceEvent& from)
1749 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1750 BinderTransactionAllocBufFtraceEvent* const _this = this; (void)_this;
1751 new (&_impl_) Impl_{
1752 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1753 , /*decltype(_impl_._cached_size_)*/{}
1754 , decltype(_impl_.data_size_){}
1755 , decltype(_impl_.offsets_size_){}
1756 , decltype(_impl_.extra_buffers_size_){}
1757 , decltype(_impl_.debug_id_){}};
1758
1759 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1760 ::memcpy(&_impl_.data_size_, &from._impl_.data_size_,
1761 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.debug_id_) -
1762 reinterpret_cast<char*>(&_impl_.data_size_)) + sizeof(_impl_.debug_id_));
1763 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1764 }
1765
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1766 inline void BinderTransactionAllocBufFtraceEvent::SharedCtor(
1767 ::_pb::Arena* arena, bool is_message_owned) {
1768 (void)arena;
1769 (void)is_message_owned;
1770 new (&_impl_) Impl_{
1771 decltype(_impl_._has_bits_){}
1772 , /*decltype(_impl_._cached_size_)*/{}
1773 , decltype(_impl_.data_size_){::uint64_t{0u}}
1774 , decltype(_impl_.offsets_size_){::uint64_t{0u}}
1775 , decltype(_impl_.extra_buffers_size_){::uint64_t{0u}}
1776 , decltype(_impl_.debug_id_){0}
1777 };
1778 }
1779
~BinderTransactionAllocBufFtraceEvent()1780 BinderTransactionAllocBufFtraceEvent::~BinderTransactionAllocBufFtraceEvent() {
1781 // @@protoc_insertion_point(destructor:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1782 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1783 (void)arena;
1784 return;
1785 }
1786 SharedDtor();
1787 }
1788
SharedDtor()1789 inline void BinderTransactionAllocBufFtraceEvent::SharedDtor() {
1790 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1791 }
1792
SetCachedSize(int size) const1793 void BinderTransactionAllocBufFtraceEvent::SetCachedSize(int size) const {
1794 _impl_._cached_size_.Set(size);
1795 }
1796
Clear()1797 void BinderTransactionAllocBufFtraceEvent::Clear() {
1798 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1799 ::uint32_t cached_has_bits = 0;
1800 // Prevent compiler warnings about cached_has_bits being unused
1801 (void) cached_has_bits;
1802
1803 cached_has_bits = _impl_._has_bits_[0];
1804 if (cached_has_bits & 0x0000000fu) {
1805 ::memset(&_impl_.data_size_, 0, static_cast<size_t>(
1806 reinterpret_cast<char*>(&_impl_.debug_id_) -
1807 reinterpret_cast<char*>(&_impl_.data_size_)) + sizeof(_impl_.debug_id_));
1808 }
1809 _impl_._has_bits_.Clear();
1810 _internal_metadata_.Clear<std::string>();
1811 }
1812
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1813 const char* BinderTransactionAllocBufFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1814 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1815 _Internal::HasBits has_bits{};
1816 while (!ctx->Done(&ptr)) {
1817 ::uint32_t tag;
1818 ptr = ::_pbi::ReadTag(ptr, &tag);
1819 switch (tag >> 3) {
1820 // optional uint64 data_size = 1;
1821 case 1:
1822 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1823 _Internal::set_has_data_size(&has_bits);
1824 _impl_.data_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1825 CHK_(ptr);
1826 } else {
1827 goto handle_unusual;
1828 }
1829 continue;
1830 // optional int32 debug_id = 2;
1831 case 2:
1832 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1833 _Internal::set_has_debug_id(&has_bits);
1834 _impl_.debug_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1835 CHK_(ptr);
1836 } else {
1837 goto handle_unusual;
1838 }
1839 continue;
1840 // optional uint64 offsets_size = 3;
1841 case 3:
1842 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1843 _Internal::set_has_offsets_size(&has_bits);
1844 _impl_.offsets_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1845 CHK_(ptr);
1846 } else {
1847 goto handle_unusual;
1848 }
1849 continue;
1850 // optional uint64 extra_buffers_size = 4;
1851 case 4:
1852 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1853 _Internal::set_has_extra_buffers_size(&has_bits);
1854 _impl_.extra_buffers_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1855 CHK_(ptr);
1856 } else {
1857 goto handle_unusual;
1858 }
1859 continue;
1860 default:
1861 goto handle_unusual;
1862 } // switch
1863 handle_unusual:
1864 if ((tag == 0) || ((tag & 7) == 4)) {
1865 CHK_(ptr);
1866 ctx->SetLastTag(tag);
1867 goto message_done;
1868 }
1869 ptr = UnknownFieldParse(
1870 tag,
1871 _internal_metadata_.mutable_unknown_fields<std::string>(),
1872 ptr, ctx);
1873 CHK_(ptr != nullptr);
1874 } // while
1875 message_done:
1876 _impl_._has_bits_.Or(has_bits);
1877 return ptr;
1878 failure:
1879 ptr = nullptr;
1880 goto message_done;
1881 #undef CHK_
1882 }
1883
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1884 ::uint8_t* BinderTransactionAllocBufFtraceEvent::_InternalSerialize(
1885 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1886 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1887 ::uint32_t cached_has_bits = 0;
1888 (void) cached_has_bits;
1889
1890 cached_has_bits = _impl_._has_bits_[0];
1891 // optional uint64 data_size = 1;
1892 if (cached_has_bits & 0x00000001u) {
1893 target = stream->EnsureSpace(target);
1894 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_data_size(), target);
1895 }
1896
1897 // optional int32 debug_id = 2;
1898 if (cached_has_bits & 0x00000008u) {
1899 target = stream->EnsureSpace(target);
1900 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_debug_id(), target);
1901 }
1902
1903 // optional uint64 offsets_size = 3;
1904 if (cached_has_bits & 0x00000002u) {
1905 target = stream->EnsureSpace(target);
1906 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_offsets_size(), target);
1907 }
1908
1909 // optional uint64 extra_buffers_size = 4;
1910 if (cached_has_bits & 0x00000004u) {
1911 target = stream->EnsureSpace(target);
1912 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_extra_buffers_size(), target);
1913 }
1914
1915 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1916 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1917 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1918 }
1919 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1920 return target;
1921 }
1922
ByteSizeLong() const1923 size_t BinderTransactionAllocBufFtraceEvent::ByteSizeLong() const {
1924 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1925 size_t total_size = 0;
1926
1927 ::uint32_t cached_has_bits = 0;
1928 // Prevent compiler warnings about cached_has_bits being unused
1929 (void) cached_has_bits;
1930
1931 cached_has_bits = _impl_._has_bits_[0];
1932 if (cached_has_bits & 0x0000000fu) {
1933 // optional uint64 data_size = 1;
1934 if (cached_has_bits & 0x00000001u) {
1935 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_data_size());
1936 }
1937
1938 // optional uint64 offsets_size = 3;
1939 if (cached_has_bits & 0x00000002u) {
1940 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_offsets_size());
1941 }
1942
1943 // optional uint64 extra_buffers_size = 4;
1944 if (cached_has_bits & 0x00000004u) {
1945 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_extra_buffers_size());
1946 }
1947
1948 // optional int32 debug_id = 2;
1949 if (cached_has_bits & 0x00000008u) {
1950 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_debug_id());
1951 }
1952
1953 }
1954 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1955 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1956 }
1957 int cached_size = ::_pbi::ToCachedSize(total_size);
1958 SetCachedSize(cached_size);
1959 return total_size;
1960 }
1961
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1962 void BinderTransactionAllocBufFtraceEvent::CheckTypeAndMergeFrom(
1963 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1964 MergeFrom(*::_pbi::DownCast<const BinderTransactionAllocBufFtraceEvent*>(
1965 &from));
1966 }
1967
MergeFrom(const BinderTransactionAllocBufFtraceEvent & from)1968 void BinderTransactionAllocBufFtraceEvent::MergeFrom(const BinderTransactionAllocBufFtraceEvent& from) {
1969 BinderTransactionAllocBufFtraceEvent* const _this = this;
1970 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1971 GOOGLE_DCHECK_NE(&from, _this);
1972 ::uint32_t cached_has_bits = 0;
1973 (void) cached_has_bits;
1974
1975 cached_has_bits = from._impl_._has_bits_[0];
1976 if (cached_has_bits & 0x0000000fu) {
1977 if (cached_has_bits & 0x00000001u) {
1978 _this->_impl_.data_size_ = from._impl_.data_size_;
1979 }
1980 if (cached_has_bits & 0x00000002u) {
1981 _this->_impl_.offsets_size_ = from._impl_.offsets_size_;
1982 }
1983 if (cached_has_bits & 0x00000004u) {
1984 _this->_impl_.extra_buffers_size_ = from._impl_.extra_buffers_size_;
1985 }
1986 if (cached_has_bits & 0x00000008u) {
1987 _this->_impl_.debug_id_ = from._impl_.debug_id_;
1988 }
1989 _this->_impl_._has_bits_[0] |= cached_has_bits;
1990 }
1991 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1992 }
1993
CopyFrom(const BinderTransactionAllocBufFtraceEvent & from)1994 void BinderTransactionAllocBufFtraceEvent::CopyFrom(const BinderTransactionAllocBufFtraceEvent& from) {
1995 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderTransactionAllocBufFtraceEvent)
1996 if (&from == this) return;
1997 Clear();
1998 MergeFrom(from);
1999 }
2000
IsInitialized() const2001 bool BinderTransactionAllocBufFtraceEvent::IsInitialized() const {
2002 return true;
2003 }
2004
InternalSwap(BinderTransactionAllocBufFtraceEvent * other)2005 void BinderTransactionAllocBufFtraceEvent::InternalSwap(BinderTransactionAllocBufFtraceEvent* other) {
2006 using std::swap;
2007 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2008 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2009 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2010 PROTOBUF_FIELD_OFFSET(BinderTransactionAllocBufFtraceEvent, _impl_.debug_id_)
2011 + sizeof(BinderTransactionAllocBufFtraceEvent::_impl_.debug_id_) // NOLINT
2012 - PROTOBUF_FIELD_OFFSET(BinderTransactionAllocBufFtraceEvent, _impl_.data_size_)>(
2013 reinterpret_cast<char*>(&_impl_.data_size_),
2014 reinterpret_cast<char*>(&other->_impl_.data_size_));
2015 }
2016
GetTypeName() const2017 std::string BinderTransactionAllocBufFtraceEvent::GetTypeName() const {
2018 return "perfetto.protos.BinderTransactionAllocBufFtraceEvent";
2019 }
2020
2021
2022 // ===================================================================
2023
2024 class BinderCommandFtraceEvent::_Internal {
2025 public:
2026 using HasBits = decltype(std::declval<BinderCommandFtraceEvent>()._impl_._has_bits_);
set_has_cmd(HasBits * has_bits)2027 static void set_has_cmd(HasBits* has_bits) {
2028 (*has_bits)[0] |= 1u;
2029 }
2030 };
2031
BinderCommandFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2032 BinderCommandFtraceEvent::BinderCommandFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2033 bool is_message_owned)
2034 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2035 SharedCtor(arena, is_message_owned);
2036 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderCommandFtraceEvent)
2037 }
BinderCommandFtraceEvent(const BinderCommandFtraceEvent & from)2038 BinderCommandFtraceEvent::BinderCommandFtraceEvent(const BinderCommandFtraceEvent& from)
2039 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2040 BinderCommandFtraceEvent* const _this = this; (void)_this;
2041 new (&_impl_) Impl_{
2042 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2043 , /*decltype(_impl_._cached_size_)*/{}
2044 , decltype(_impl_.cmd_){}};
2045
2046 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2047 _this->_impl_.cmd_ = from._impl_.cmd_;
2048 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderCommandFtraceEvent)
2049 }
2050
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2051 inline void BinderCommandFtraceEvent::SharedCtor(
2052 ::_pb::Arena* arena, bool is_message_owned) {
2053 (void)arena;
2054 (void)is_message_owned;
2055 new (&_impl_) Impl_{
2056 decltype(_impl_._has_bits_){}
2057 , /*decltype(_impl_._cached_size_)*/{}
2058 , decltype(_impl_.cmd_){0u}
2059 };
2060 }
2061
~BinderCommandFtraceEvent()2062 BinderCommandFtraceEvent::~BinderCommandFtraceEvent() {
2063 // @@protoc_insertion_point(destructor:perfetto.protos.BinderCommandFtraceEvent)
2064 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2065 (void)arena;
2066 return;
2067 }
2068 SharedDtor();
2069 }
2070
SharedDtor()2071 inline void BinderCommandFtraceEvent::SharedDtor() {
2072 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2073 }
2074
SetCachedSize(int size) const2075 void BinderCommandFtraceEvent::SetCachedSize(int size) const {
2076 _impl_._cached_size_.Set(size);
2077 }
2078
Clear()2079 void BinderCommandFtraceEvent::Clear() {
2080 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderCommandFtraceEvent)
2081 ::uint32_t cached_has_bits = 0;
2082 // Prevent compiler warnings about cached_has_bits being unused
2083 (void) cached_has_bits;
2084
2085 _impl_.cmd_ = 0u;
2086 _impl_._has_bits_.Clear();
2087 _internal_metadata_.Clear<std::string>();
2088 }
2089
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2090 const char* BinderCommandFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2091 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2092 _Internal::HasBits has_bits{};
2093 while (!ctx->Done(&ptr)) {
2094 ::uint32_t tag;
2095 ptr = ::_pbi::ReadTag(ptr, &tag);
2096 switch (tag >> 3) {
2097 // optional uint32 cmd = 1;
2098 case 1:
2099 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2100 _Internal::set_has_cmd(&has_bits);
2101 _impl_.cmd_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2102 CHK_(ptr);
2103 } else {
2104 goto handle_unusual;
2105 }
2106 continue;
2107 default:
2108 goto handle_unusual;
2109 } // switch
2110 handle_unusual:
2111 if ((tag == 0) || ((tag & 7) == 4)) {
2112 CHK_(ptr);
2113 ctx->SetLastTag(tag);
2114 goto message_done;
2115 }
2116 ptr = UnknownFieldParse(
2117 tag,
2118 _internal_metadata_.mutable_unknown_fields<std::string>(),
2119 ptr, ctx);
2120 CHK_(ptr != nullptr);
2121 } // while
2122 message_done:
2123 _impl_._has_bits_.Or(has_bits);
2124 return ptr;
2125 failure:
2126 ptr = nullptr;
2127 goto message_done;
2128 #undef CHK_
2129 }
2130
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2131 ::uint8_t* BinderCommandFtraceEvent::_InternalSerialize(
2132 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2133 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderCommandFtraceEvent)
2134 ::uint32_t cached_has_bits = 0;
2135 (void) cached_has_bits;
2136
2137 cached_has_bits = _impl_._has_bits_[0];
2138 // optional uint32 cmd = 1;
2139 if (cached_has_bits & 0x00000001u) {
2140 target = stream->EnsureSpace(target);
2141 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_cmd(), target);
2142 }
2143
2144 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2145 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2146 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2147 }
2148 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderCommandFtraceEvent)
2149 return target;
2150 }
2151
ByteSizeLong() const2152 size_t BinderCommandFtraceEvent::ByteSizeLong() const {
2153 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderCommandFtraceEvent)
2154 size_t total_size = 0;
2155
2156 ::uint32_t cached_has_bits = 0;
2157 // Prevent compiler warnings about cached_has_bits being unused
2158 (void) cached_has_bits;
2159
2160 // optional uint32 cmd = 1;
2161 cached_has_bits = _impl_._has_bits_[0];
2162 if (cached_has_bits & 0x00000001u) {
2163 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cmd());
2164 }
2165
2166 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2167 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2168 }
2169 int cached_size = ::_pbi::ToCachedSize(total_size);
2170 SetCachedSize(cached_size);
2171 return total_size;
2172 }
2173
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2174 void BinderCommandFtraceEvent::CheckTypeAndMergeFrom(
2175 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2176 MergeFrom(*::_pbi::DownCast<const BinderCommandFtraceEvent*>(
2177 &from));
2178 }
2179
MergeFrom(const BinderCommandFtraceEvent & from)2180 void BinderCommandFtraceEvent::MergeFrom(const BinderCommandFtraceEvent& from) {
2181 BinderCommandFtraceEvent* const _this = this;
2182 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderCommandFtraceEvent)
2183 GOOGLE_DCHECK_NE(&from, _this);
2184 ::uint32_t cached_has_bits = 0;
2185 (void) cached_has_bits;
2186
2187 if (from._internal_has_cmd()) {
2188 _this->_internal_set_cmd(from._internal_cmd());
2189 }
2190 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2191 }
2192
CopyFrom(const BinderCommandFtraceEvent & from)2193 void BinderCommandFtraceEvent::CopyFrom(const BinderCommandFtraceEvent& from) {
2194 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderCommandFtraceEvent)
2195 if (&from == this) return;
2196 Clear();
2197 MergeFrom(from);
2198 }
2199
IsInitialized() const2200 bool BinderCommandFtraceEvent::IsInitialized() const {
2201 return true;
2202 }
2203
InternalSwap(BinderCommandFtraceEvent * other)2204 void BinderCommandFtraceEvent::InternalSwap(BinderCommandFtraceEvent* other) {
2205 using std::swap;
2206 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2207 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2208 swap(_impl_.cmd_, other->_impl_.cmd_);
2209 }
2210
GetTypeName() const2211 std::string BinderCommandFtraceEvent::GetTypeName() const {
2212 return "perfetto.protos.BinderCommandFtraceEvent";
2213 }
2214
2215
2216 // ===================================================================
2217
2218 class BinderReturnFtraceEvent::_Internal {
2219 public:
2220 using HasBits = decltype(std::declval<BinderReturnFtraceEvent>()._impl_._has_bits_);
set_has_cmd(HasBits * has_bits)2221 static void set_has_cmd(HasBits* has_bits) {
2222 (*has_bits)[0] |= 1u;
2223 }
2224 };
2225
BinderReturnFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2226 BinderReturnFtraceEvent::BinderReturnFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2227 bool is_message_owned)
2228 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2229 SharedCtor(arena, is_message_owned);
2230 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BinderReturnFtraceEvent)
2231 }
BinderReturnFtraceEvent(const BinderReturnFtraceEvent & from)2232 BinderReturnFtraceEvent::BinderReturnFtraceEvent(const BinderReturnFtraceEvent& from)
2233 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2234 BinderReturnFtraceEvent* const _this = this; (void)_this;
2235 new (&_impl_) Impl_{
2236 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2237 , /*decltype(_impl_._cached_size_)*/{}
2238 , decltype(_impl_.cmd_){}};
2239
2240 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2241 _this->_impl_.cmd_ = from._impl_.cmd_;
2242 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BinderReturnFtraceEvent)
2243 }
2244
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2245 inline void BinderReturnFtraceEvent::SharedCtor(
2246 ::_pb::Arena* arena, bool is_message_owned) {
2247 (void)arena;
2248 (void)is_message_owned;
2249 new (&_impl_) Impl_{
2250 decltype(_impl_._has_bits_){}
2251 , /*decltype(_impl_._cached_size_)*/{}
2252 , decltype(_impl_.cmd_){0u}
2253 };
2254 }
2255
~BinderReturnFtraceEvent()2256 BinderReturnFtraceEvent::~BinderReturnFtraceEvent() {
2257 // @@protoc_insertion_point(destructor:perfetto.protos.BinderReturnFtraceEvent)
2258 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2259 (void)arena;
2260 return;
2261 }
2262 SharedDtor();
2263 }
2264
SharedDtor()2265 inline void BinderReturnFtraceEvent::SharedDtor() {
2266 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2267 }
2268
SetCachedSize(int size) const2269 void BinderReturnFtraceEvent::SetCachedSize(int size) const {
2270 _impl_._cached_size_.Set(size);
2271 }
2272
Clear()2273 void BinderReturnFtraceEvent::Clear() {
2274 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BinderReturnFtraceEvent)
2275 ::uint32_t cached_has_bits = 0;
2276 // Prevent compiler warnings about cached_has_bits being unused
2277 (void) cached_has_bits;
2278
2279 _impl_.cmd_ = 0u;
2280 _impl_._has_bits_.Clear();
2281 _internal_metadata_.Clear<std::string>();
2282 }
2283
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2284 const char* BinderReturnFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2285 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2286 _Internal::HasBits has_bits{};
2287 while (!ctx->Done(&ptr)) {
2288 ::uint32_t tag;
2289 ptr = ::_pbi::ReadTag(ptr, &tag);
2290 switch (tag >> 3) {
2291 // optional uint32 cmd = 1;
2292 case 1:
2293 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2294 _Internal::set_has_cmd(&has_bits);
2295 _impl_.cmd_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2296 CHK_(ptr);
2297 } else {
2298 goto handle_unusual;
2299 }
2300 continue;
2301 default:
2302 goto handle_unusual;
2303 } // switch
2304 handle_unusual:
2305 if ((tag == 0) || ((tag & 7) == 4)) {
2306 CHK_(ptr);
2307 ctx->SetLastTag(tag);
2308 goto message_done;
2309 }
2310 ptr = UnknownFieldParse(
2311 tag,
2312 _internal_metadata_.mutable_unknown_fields<std::string>(),
2313 ptr, ctx);
2314 CHK_(ptr != nullptr);
2315 } // while
2316 message_done:
2317 _impl_._has_bits_.Or(has_bits);
2318 return ptr;
2319 failure:
2320 ptr = nullptr;
2321 goto message_done;
2322 #undef CHK_
2323 }
2324
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2325 ::uint8_t* BinderReturnFtraceEvent::_InternalSerialize(
2326 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2327 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BinderReturnFtraceEvent)
2328 ::uint32_t cached_has_bits = 0;
2329 (void) cached_has_bits;
2330
2331 cached_has_bits = _impl_._has_bits_[0];
2332 // optional uint32 cmd = 1;
2333 if (cached_has_bits & 0x00000001u) {
2334 target = stream->EnsureSpace(target);
2335 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_cmd(), target);
2336 }
2337
2338 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2339 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2340 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2341 }
2342 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BinderReturnFtraceEvent)
2343 return target;
2344 }
2345
ByteSizeLong() const2346 size_t BinderReturnFtraceEvent::ByteSizeLong() const {
2347 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BinderReturnFtraceEvent)
2348 size_t total_size = 0;
2349
2350 ::uint32_t cached_has_bits = 0;
2351 // Prevent compiler warnings about cached_has_bits being unused
2352 (void) cached_has_bits;
2353
2354 // optional uint32 cmd = 1;
2355 cached_has_bits = _impl_._has_bits_[0];
2356 if (cached_has_bits & 0x00000001u) {
2357 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cmd());
2358 }
2359
2360 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2361 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2362 }
2363 int cached_size = ::_pbi::ToCachedSize(total_size);
2364 SetCachedSize(cached_size);
2365 return total_size;
2366 }
2367
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2368 void BinderReturnFtraceEvent::CheckTypeAndMergeFrom(
2369 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2370 MergeFrom(*::_pbi::DownCast<const BinderReturnFtraceEvent*>(
2371 &from));
2372 }
2373
MergeFrom(const BinderReturnFtraceEvent & from)2374 void BinderReturnFtraceEvent::MergeFrom(const BinderReturnFtraceEvent& from) {
2375 BinderReturnFtraceEvent* const _this = this;
2376 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BinderReturnFtraceEvent)
2377 GOOGLE_DCHECK_NE(&from, _this);
2378 ::uint32_t cached_has_bits = 0;
2379 (void) cached_has_bits;
2380
2381 if (from._internal_has_cmd()) {
2382 _this->_internal_set_cmd(from._internal_cmd());
2383 }
2384 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2385 }
2386
CopyFrom(const BinderReturnFtraceEvent & from)2387 void BinderReturnFtraceEvent::CopyFrom(const BinderReturnFtraceEvent& from) {
2388 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BinderReturnFtraceEvent)
2389 if (&from == this) return;
2390 Clear();
2391 MergeFrom(from);
2392 }
2393
IsInitialized() const2394 bool BinderReturnFtraceEvent::IsInitialized() const {
2395 return true;
2396 }
2397
InternalSwap(BinderReturnFtraceEvent * other)2398 void BinderReturnFtraceEvent::InternalSwap(BinderReturnFtraceEvent* other) {
2399 using std::swap;
2400 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2401 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2402 swap(_impl_.cmd_, other->_impl_.cmd_);
2403 }
2404
GetTypeName() const2405 std::string BinderReturnFtraceEvent::GetTypeName() const {
2406 return "perfetto.protos.BinderReturnFtraceEvent";
2407 }
2408
2409
2410 // @@protoc_insertion_point(namespace_scope)
2411 } // namespace protos
2412 } // namespace perfetto
2413 PROTOBUF_NAMESPACE_OPEN
2414 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderTransactionFtraceEvent*
CreateMaybeMessage(Arena * arena)2415 Arena::CreateMaybeMessage< ::perfetto::protos::BinderTransactionFtraceEvent >(Arena* arena) {
2416 return Arena::CreateMessageInternal< ::perfetto::protos::BinderTransactionFtraceEvent >(arena);
2417 }
2418 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderTransactionReceivedFtraceEvent*
CreateMaybeMessage(Arena * arena)2419 Arena::CreateMaybeMessage< ::perfetto::protos::BinderTransactionReceivedFtraceEvent >(Arena* arena) {
2420 return Arena::CreateMessageInternal< ::perfetto::protos::BinderTransactionReceivedFtraceEvent >(arena);
2421 }
2422 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderSetPriorityFtraceEvent*
CreateMaybeMessage(Arena * arena)2423 Arena::CreateMaybeMessage< ::perfetto::protos::BinderSetPriorityFtraceEvent >(Arena* arena) {
2424 return Arena::CreateMessageInternal< ::perfetto::protos::BinderSetPriorityFtraceEvent >(arena);
2425 }
2426 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderLockFtraceEvent*
CreateMaybeMessage(Arena * arena)2427 Arena::CreateMaybeMessage< ::perfetto::protos::BinderLockFtraceEvent >(Arena* arena) {
2428 return Arena::CreateMessageInternal< ::perfetto::protos::BinderLockFtraceEvent >(arena);
2429 }
2430 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderLockedFtraceEvent*
CreateMaybeMessage(Arena * arena)2431 Arena::CreateMaybeMessage< ::perfetto::protos::BinderLockedFtraceEvent >(Arena* arena) {
2432 return Arena::CreateMessageInternal< ::perfetto::protos::BinderLockedFtraceEvent >(arena);
2433 }
2434 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderUnlockFtraceEvent*
CreateMaybeMessage(Arena * arena)2435 Arena::CreateMaybeMessage< ::perfetto::protos::BinderUnlockFtraceEvent >(Arena* arena) {
2436 return Arena::CreateMessageInternal< ::perfetto::protos::BinderUnlockFtraceEvent >(arena);
2437 }
2438 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderTransactionAllocBufFtraceEvent*
CreateMaybeMessage(Arena * arena)2439 Arena::CreateMaybeMessage< ::perfetto::protos::BinderTransactionAllocBufFtraceEvent >(Arena* arena) {
2440 return Arena::CreateMessageInternal< ::perfetto::protos::BinderTransactionAllocBufFtraceEvent >(arena);
2441 }
2442 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderCommandFtraceEvent*
CreateMaybeMessage(Arena * arena)2443 Arena::CreateMaybeMessage< ::perfetto::protos::BinderCommandFtraceEvent >(Arena* arena) {
2444 return Arena::CreateMessageInternal< ::perfetto::protos::BinderCommandFtraceEvent >(arena);
2445 }
2446 template<> PROTOBUF_NOINLINE ::perfetto::protos::BinderReturnFtraceEvent*
CreateMaybeMessage(Arena * arena)2447 Arena::CreateMaybeMessage< ::perfetto::protos::BinderReturnFtraceEvent >(Arena* arena) {
2448 return Arena::CreateMessageInternal< ::perfetto::protos::BinderReturnFtraceEvent >(arena);
2449 }
2450 PROTOBUF_NAMESPACE_CLOSE
2451
2452 // @@protoc_insertion_point(global_scope)
2453 #include <google/protobuf/port_undef.inc>
2454