1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/i2c.proto
3
4 #include "protos/perfetto/trace/ftrace/i2c.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 {
I2cReadFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR I2cReadFtraceEvent::I2cReadFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.adapter_nr_)*/0
28 , /*decltype(_impl_.msg_nr_)*/0u
29 , /*decltype(_impl_.addr_)*/0u
30 , /*decltype(_impl_.flags_)*/0u
31 , /*decltype(_impl_.len_)*/0u} {}
32 struct I2cReadFtraceEventDefaultTypeInternal {
I2cReadFtraceEventDefaultTypeInternalperfetto::protos::I2cReadFtraceEventDefaultTypeInternal33 PROTOBUF_CONSTEXPR I2cReadFtraceEventDefaultTypeInternal()
34 : _instance(::_pbi::ConstantInitialized{}) {}
~I2cReadFtraceEventDefaultTypeInternalperfetto::protos::I2cReadFtraceEventDefaultTypeInternal35 ~I2cReadFtraceEventDefaultTypeInternal() {}
36 union { // NOLINT(misc-non-private-member-variables-in-classes)
37 I2cReadFtraceEvent _instance;
38 };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 I2cReadFtraceEventDefaultTypeInternal _I2cReadFtraceEvent_default_instance_;
I2cWriteFtraceEvent(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR I2cWriteFtraceEvent::I2cWriteFtraceEvent(
42 ::_pbi::ConstantInitialized): _impl_{
43 /*decltype(_impl_._has_bits_)*/{}
44 , /*decltype(_impl_._cached_size_)*/{}
45 , /*decltype(_impl_.adapter_nr_)*/0
46 , /*decltype(_impl_.msg_nr_)*/0u
47 , /*decltype(_impl_.addr_)*/0u
48 , /*decltype(_impl_.flags_)*/0u
49 , /*decltype(_impl_.len_)*/0u
50 , /*decltype(_impl_.buf_)*/0u} {}
51 struct I2cWriteFtraceEventDefaultTypeInternal {
I2cWriteFtraceEventDefaultTypeInternalperfetto::protos::I2cWriteFtraceEventDefaultTypeInternal52 PROTOBUF_CONSTEXPR I2cWriteFtraceEventDefaultTypeInternal()
53 : _instance(::_pbi::ConstantInitialized{}) {}
~I2cWriteFtraceEventDefaultTypeInternalperfetto::protos::I2cWriteFtraceEventDefaultTypeInternal54 ~I2cWriteFtraceEventDefaultTypeInternal() {}
55 union { // NOLINT(misc-non-private-member-variables-in-classes)
56 I2cWriteFtraceEvent _instance;
57 };
58 };
59 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 I2cWriteFtraceEventDefaultTypeInternal _I2cWriteFtraceEvent_default_instance_;
I2cResultFtraceEvent(::_pbi::ConstantInitialized)60 PROTOBUF_CONSTEXPR I2cResultFtraceEvent::I2cResultFtraceEvent(
61 ::_pbi::ConstantInitialized): _impl_{
62 /*decltype(_impl_._has_bits_)*/{}
63 , /*decltype(_impl_._cached_size_)*/{}
64 , /*decltype(_impl_.adapter_nr_)*/0
65 , /*decltype(_impl_.nr_msgs_)*/0u
66 , /*decltype(_impl_.ret_)*/0} {}
67 struct I2cResultFtraceEventDefaultTypeInternal {
I2cResultFtraceEventDefaultTypeInternalperfetto::protos::I2cResultFtraceEventDefaultTypeInternal68 PROTOBUF_CONSTEXPR I2cResultFtraceEventDefaultTypeInternal()
69 : _instance(::_pbi::ConstantInitialized{}) {}
~I2cResultFtraceEventDefaultTypeInternalperfetto::protos::I2cResultFtraceEventDefaultTypeInternal70 ~I2cResultFtraceEventDefaultTypeInternal() {}
71 union { // NOLINT(misc-non-private-member-variables-in-classes)
72 I2cResultFtraceEvent _instance;
73 };
74 };
75 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 I2cResultFtraceEventDefaultTypeInternal _I2cResultFtraceEvent_default_instance_;
I2cReplyFtraceEvent(::_pbi::ConstantInitialized)76 PROTOBUF_CONSTEXPR I2cReplyFtraceEvent::I2cReplyFtraceEvent(
77 ::_pbi::ConstantInitialized): _impl_{
78 /*decltype(_impl_._has_bits_)*/{}
79 , /*decltype(_impl_._cached_size_)*/{}
80 , /*decltype(_impl_.adapter_nr_)*/0
81 , /*decltype(_impl_.msg_nr_)*/0u
82 , /*decltype(_impl_.addr_)*/0u
83 , /*decltype(_impl_.flags_)*/0u
84 , /*decltype(_impl_.len_)*/0u
85 , /*decltype(_impl_.buf_)*/0u} {}
86 struct I2cReplyFtraceEventDefaultTypeInternal {
I2cReplyFtraceEventDefaultTypeInternalperfetto::protos::I2cReplyFtraceEventDefaultTypeInternal87 PROTOBUF_CONSTEXPR I2cReplyFtraceEventDefaultTypeInternal()
88 : _instance(::_pbi::ConstantInitialized{}) {}
~I2cReplyFtraceEventDefaultTypeInternalperfetto::protos::I2cReplyFtraceEventDefaultTypeInternal89 ~I2cReplyFtraceEventDefaultTypeInternal() {}
90 union { // NOLINT(misc-non-private-member-variables-in-classes)
91 I2cReplyFtraceEvent _instance;
92 };
93 };
94 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 I2cReplyFtraceEventDefaultTypeInternal _I2cReplyFtraceEvent_default_instance_;
SmbusReadFtraceEvent(::_pbi::ConstantInitialized)95 PROTOBUF_CONSTEXPR SmbusReadFtraceEvent::SmbusReadFtraceEvent(
96 ::_pbi::ConstantInitialized): _impl_{
97 /*decltype(_impl_._has_bits_)*/{}
98 , /*decltype(_impl_._cached_size_)*/{}
99 , /*decltype(_impl_.adapter_nr_)*/0
100 , /*decltype(_impl_.flags_)*/0u
101 , /*decltype(_impl_.addr_)*/0u
102 , /*decltype(_impl_.command_)*/0u
103 , /*decltype(_impl_.protocol_)*/0u} {}
104 struct SmbusReadFtraceEventDefaultTypeInternal {
SmbusReadFtraceEventDefaultTypeInternalperfetto::protos::SmbusReadFtraceEventDefaultTypeInternal105 PROTOBUF_CONSTEXPR SmbusReadFtraceEventDefaultTypeInternal()
106 : _instance(::_pbi::ConstantInitialized{}) {}
~SmbusReadFtraceEventDefaultTypeInternalperfetto::protos::SmbusReadFtraceEventDefaultTypeInternal107 ~SmbusReadFtraceEventDefaultTypeInternal() {}
108 union { // NOLINT(misc-non-private-member-variables-in-classes)
109 SmbusReadFtraceEvent _instance;
110 };
111 };
112 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SmbusReadFtraceEventDefaultTypeInternal _SmbusReadFtraceEvent_default_instance_;
SmbusWriteFtraceEvent(::_pbi::ConstantInitialized)113 PROTOBUF_CONSTEXPR SmbusWriteFtraceEvent::SmbusWriteFtraceEvent(
114 ::_pbi::ConstantInitialized): _impl_{
115 /*decltype(_impl_._has_bits_)*/{}
116 , /*decltype(_impl_._cached_size_)*/{}
117 , /*decltype(_impl_.adapter_nr_)*/0
118 , /*decltype(_impl_.addr_)*/0u
119 , /*decltype(_impl_.flags_)*/0u
120 , /*decltype(_impl_.command_)*/0u
121 , /*decltype(_impl_.len_)*/0u
122 , /*decltype(_impl_.protocol_)*/0u} {}
123 struct SmbusWriteFtraceEventDefaultTypeInternal {
SmbusWriteFtraceEventDefaultTypeInternalperfetto::protos::SmbusWriteFtraceEventDefaultTypeInternal124 PROTOBUF_CONSTEXPR SmbusWriteFtraceEventDefaultTypeInternal()
125 : _instance(::_pbi::ConstantInitialized{}) {}
~SmbusWriteFtraceEventDefaultTypeInternalperfetto::protos::SmbusWriteFtraceEventDefaultTypeInternal126 ~SmbusWriteFtraceEventDefaultTypeInternal() {}
127 union { // NOLINT(misc-non-private-member-variables-in-classes)
128 SmbusWriteFtraceEvent _instance;
129 };
130 };
131 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SmbusWriteFtraceEventDefaultTypeInternal _SmbusWriteFtraceEvent_default_instance_;
SmbusResultFtraceEvent(::_pbi::ConstantInitialized)132 PROTOBUF_CONSTEXPR SmbusResultFtraceEvent::SmbusResultFtraceEvent(
133 ::_pbi::ConstantInitialized): _impl_{
134 /*decltype(_impl_._has_bits_)*/{}
135 , /*decltype(_impl_._cached_size_)*/{}
136 , /*decltype(_impl_.adapter_nr_)*/0
137 , /*decltype(_impl_.addr_)*/0u
138 , /*decltype(_impl_.flags_)*/0u
139 , /*decltype(_impl_.read_write_)*/0u
140 , /*decltype(_impl_.command_)*/0u
141 , /*decltype(_impl_.res_)*/0
142 , /*decltype(_impl_.protocol_)*/0u} {}
143 struct SmbusResultFtraceEventDefaultTypeInternal {
SmbusResultFtraceEventDefaultTypeInternalperfetto::protos::SmbusResultFtraceEventDefaultTypeInternal144 PROTOBUF_CONSTEXPR SmbusResultFtraceEventDefaultTypeInternal()
145 : _instance(::_pbi::ConstantInitialized{}) {}
~SmbusResultFtraceEventDefaultTypeInternalperfetto::protos::SmbusResultFtraceEventDefaultTypeInternal146 ~SmbusResultFtraceEventDefaultTypeInternal() {}
147 union { // NOLINT(misc-non-private-member-variables-in-classes)
148 SmbusResultFtraceEvent _instance;
149 };
150 };
151 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SmbusResultFtraceEventDefaultTypeInternal _SmbusResultFtraceEvent_default_instance_;
SmbusReplyFtraceEvent(::_pbi::ConstantInitialized)152 PROTOBUF_CONSTEXPR SmbusReplyFtraceEvent::SmbusReplyFtraceEvent(
153 ::_pbi::ConstantInitialized): _impl_{
154 /*decltype(_impl_._has_bits_)*/{}
155 , /*decltype(_impl_._cached_size_)*/{}
156 , /*decltype(_impl_.adapter_nr_)*/0
157 , /*decltype(_impl_.addr_)*/0u
158 , /*decltype(_impl_.flags_)*/0u
159 , /*decltype(_impl_.command_)*/0u
160 , /*decltype(_impl_.len_)*/0u
161 , /*decltype(_impl_.protocol_)*/0u} {}
162 struct SmbusReplyFtraceEventDefaultTypeInternal {
SmbusReplyFtraceEventDefaultTypeInternalperfetto::protos::SmbusReplyFtraceEventDefaultTypeInternal163 PROTOBUF_CONSTEXPR SmbusReplyFtraceEventDefaultTypeInternal()
164 : _instance(::_pbi::ConstantInitialized{}) {}
~SmbusReplyFtraceEventDefaultTypeInternalperfetto::protos::SmbusReplyFtraceEventDefaultTypeInternal165 ~SmbusReplyFtraceEventDefaultTypeInternal() {}
166 union { // NOLINT(misc-non-private-member-variables-in-classes)
167 SmbusReplyFtraceEvent _instance;
168 };
169 };
170 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SmbusReplyFtraceEventDefaultTypeInternal _SmbusReplyFtraceEvent_default_instance_;
171 } // namespace protos
172 } // namespace perfetto
173 namespace perfetto {
174 namespace protos {
175
176 // ===================================================================
177
178 class I2cReadFtraceEvent::_Internal {
179 public:
180 using HasBits = decltype(std::declval<I2cReadFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)181 static void set_has_adapter_nr(HasBits* has_bits) {
182 (*has_bits)[0] |= 1u;
183 }
set_has_msg_nr(HasBits * has_bits)184 static void set_has_msg_nr(HasBits* has_bits) {
185 (*has_bits)[0] |= 2u;
186 }
set_has_addr(HasBits * has_bits)187 static void set_has_addr(HasBits* has_bits) {
188 (*has_bits)[0] |= 4u;
189 }
set_has_flags(HasBits * has_bits)190 static void set_has_flags(HasBits* has_bits) {
191 (*has_bits)[0] |= 8u;
192 }
set_has_len(HasBits * has_bits)193 static void set_has_len(HasBits* has_bits) {
194 (*has_bits)[0] |= 16u;
195 }
196 };
197
I2cReadFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)198 I2cReadFtraceEvent::I2cReadFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
199 bool is_message_owned)
200 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
201 SharedCtor(arena, is_message_owned);
202 // @@protoc_insertion_point(arena_constructor:perfetto.protos.I2cReadFtraceEvent)
203 }
I2cReadFtraceEvent(const I2cReadFtraceEvent & from)204 I2cReadFtraceEvent::I2cReadFtraceEvent(const I2cReadFtraceEvent& from)
205 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
206 I2cReadFtraceEvent* const _this = this; (void)_this;
207 new (&_impl_) Impl_{
208 decltype(_impl_._has_bits_){from._impl_._has_bits_}
209 , /*decltype(_impl_._cached_size_)*/{}
210 , decltype(_impl_.adapter_nr_){}
211 , decltype(_impl_.msg_nr_){}
212 , decltype(_impl_.addr_){}
213 , decltype(_impl_.flags_){}
214 , decltype(_impl_.len_){}};
215
216 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
217 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
218 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.len_) -
219 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.len_));
220 // @@protoc_insertion_point(copy_constructor:perfetto.protos.I2cReadFtraceEvent)
221 }
222
SharedCtor(::_pb::Arena * arena,bool is_message_owned)223 inline void I2cReadFtraceEvent::SharedCtor(
224 ::_pb::Arena* arena, bool is_message_owned) {
225 (void)arena;
226 (void)is_message_owned;
227 new (&_impl_) Impl_{
228 decltype(_impl_._has_bits_){}
229 , /*decltype(_impl_._cached_size_)*/{}
230 , decltype(_impl_.adapter_nr_){0}
231 , decltype(_impl_.msg_nr_){0u}
232 , decltype(_impl_.addr_){0u}
233 , decltype(_impl_.flags_){0u}
234 , decltype(_impl_.len_){0u}
235 };
236 }
237
~I2cReadFtraceEvent()238 I2cReadFtraceEvent::~I2cReadFtraceEvent() {
239 // @@protoc_insertion_point(destructor:perfetto.protos.I2cReadFtraceEvent)
240 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
241 (void)arena;
242 return;
243 }
244 SharedDtor();
245 }
246
SharedDtor()247 inline void I2cReadFtraceEvent::SharedDtor() {
248 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
249 }
250
SetCachedSize(int size) const251 void I2cReadFtraceEvent::SetCachedSize(int size) const {
252 _impl_._cached_size_.Set(size);
253 }
254
Clear()255 void I2cReadFtraceEvent::Clear() {
256 // @@protoc_insertion_point(message_clear_start:perfetto.protos.I2cReadFtraceEvent)
257 ::uint32_t cached_has_bits = 0;
258 // Prevent compiler warnings about cached_has_bits being unused
259 (void) cached_has_bits;
260
261 cached_has_bits = _impl_._has_bits_[0];
262 if (cached_has_bits & 0x0000001fu) {
263 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
264 reinterpret_cast<char*>(&_impl_.len_) -
265 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.len_));
266 }
267 _impl_._has_bits_.Clear();
268 _internal_metadata_.Clear<std::string>();
269 }
270
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)271 const char* I2cReadFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
272 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
273 _Internal::HasBits has_bits{};
274 while (!ctx->Done(&ptr)) {
275 ::uint32_t tag;
276 ptr = ::_pbi::ReadTag(ptr, &tag);
277 switch (tag >> 3) {
278 // optional int32 adapter_nr = 1;
279 case 1:
280 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
281 _Internal::set_has_adapter_nr(&has_bits);
282 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
283 CHK_(ptr);
284 } else {
285 goto handle_unusual;
286 }
287 continue;
288 // optional uint32 msg_nr = 2;
289 case 2:
290 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
291 _Internal::set_has_msg_nr(&has_bits);
292 _impl_.msg_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
293 CHK_(ptr);
294 } else {
295 goto handle_unusual;
296 }
297 continue;
298 // optional uint32 addr = 3;
299 case 3:
300 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
301 _Internal::set_has_addr(&has_bits);
302 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
303 CHK_(ptr);
304 } else {
305 goto handle_unusual;
306 }
307 continue;
308 // optional uint32 flags = 4;
309 case 4:
310 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
311 _Internal::set_has_flags(&has_bits);
312 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
313 CHK_(ptr);
314 } else {
315 goto handle_unusual;
316 }
317 continue;
318 // optional uint32 len = 5;
319 case 5:
320 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
321 _Internal::set_has_len(&has_bits);
322 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
323 CHK_(ptr);
324 } else {
325 goto handle_unusual;
326 }
327 continue;
328 default:
329 goto handle_unusual;
330 } // switch
331 handle_unusual:
332 if ((tag == 0) || ((tag & 7) == 4)) {
333 CHK_(ptr);
334 ctx->SetLastTag(tag);
335 goto message_done;
336 }
337 ptr = UnknownFieldParse(
338 tag,
339 _internal_metadata_.mutable_unknown_fields<std::string>(),
340 ptr, ctx);
341 CHK_(ptr != nullptr);
342 } // while
343 message_done:
344 _impl_._has_bits_.Or(has_bits);
345 return ptr;
346 failure:
347 ptr = nullptr;
348 goto message_done;
349 #undef CHK_
350 }
351
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const352 ::uint8_t* I2cReadFtraceEvent::_InternalSerialize(
353 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
354 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.I2cReadFtraceEvent)
355 ::uint32_t cached_has_bits = 0;
356 (void) cached_has_bits;
357
358 cached_has_bits = _impl_._has_bits_[0];
359 // optional int32 adapter_nr = 1;
360 if (cached_has_bits & 0x00000001u) {
361 target = stream->EnsureSpace(target);
362 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
363 }
364
365 // optional uint32 msg_nr = 2;
366 if (cached_has_bits & 0x00000002u) {
367 target = stream->EnsureSpace(target);
368 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_msg_nr(), target);
369 }
370
371 // optional uint32 addr = 3;
372 if (cached_has_bits & 0x00000004u) {
373 target = stream->EnsureSpace(target);
374 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_addr(), target);
375 }
376
377 // optional uint32 flags = 4;
378 if (cached_has_bits & 0x00000008u) {
379 target = stream->EnsureSpace(target);
380 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_flags(), target);
381 }
382
383 // optional uint32 len = 5;
384 if (cached_has_bits & 0x00000010u) {
385 target = stream->EnsureSpace(target);
386 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_len(), target);
387 }
388
389 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
390 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
391 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
392 }
393 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.I2cReadFtraceEvent)
394 return target;
395 }
396
ByteSizeLong() const397 size_t I2cReadFtraceEvent::ByteSizeLong() const {
398 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.I2cReadFtraceEvent)
399 size_t total_size = 0;
400
401 ::uint32_t cached_has_bits = 0;
402 // Prevent compiler warnings about cached_has_bits being unused
403 (void) cached_has_bits;
404
405 cached_has_bits = _impl_._has_bits_[0];
406 if (cached_has_bits & 0x0000001fu) {
407 // optional int32 adapter_nr = 1;
408 if (cached_has_bits & 0x00000001u) {
409 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
410 }
411
412 // optional uint32 msg_nr = 2;
413 if (cached_has_bits & 0x00000002u) {
414 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_msg_nr());
415 }
416
417 // optional uint32 addr = 3;
418 if (cached_has_bits & 0x00000004u) {
419 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
420 }
421
422 // optional uint32 flags = 4;
423 if (cached_has_bits & 0x00000008u) {
424 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
425 }
426
427 // optional uint32 len = 5;
428 if (cached_has_bits & 0x00000010u) {
429 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
430 }
431
432 }
433 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
434 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
435 }
436 int cached_size = ::_pbi::ToCachedSize(total_size);
437 SetCachedSize(cached_size);
438 return total_size;
439 }
440
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)441 void I2cReadFtraceEvent::CheckTypeAndMergeFrom(
442 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
443 MergeFrom(*::_pbi::DownCast<const I2cReadFtraceEvent*>(
444 &from));
445 }
446
MergeFrom(const I2cReadFtraceEvent & from)447 void I2cReadFtraceEvent::MergeFrom(const I2cReadFtraceEvent& from) {
448 I2cReadFtraceEvent* const _this = this;
449 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.I2cReadFtraceEvent)
450 GOOGLE_DCHECK_NE(&from, _this);
451 ::uint32_t cached_has_bits = 0;
452 (void) cached_has_bits;
453
454 cached_has_bits = from._impl_._has_bits_[0];
455 if (cached_has_bits & 0x0000001fu) {
456 if (cached_has_bits & 0x00000001u) {
457 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
458 }
459 if (cached_has_bits & 0x00000002u) {
460 _this->_impl_.msg_nr_ = from._impl_.msg_nr_;
461 }
462 if (cached_has_bits & 0x00000004u) {
463 _this->_impl_.addr_ = from._impl_.addr_;
464 }
465 if (cached_has_bits & 0x00000008u) {
466 _this->_impl_.flags_ = from._impl_.flags_;
467 }
468 if (cached_has_bits & 0x00000010u) {
469 _this->_impl_.len_ = from._impl_.len_;
470 }
471 _this->_impl_._has_bits_[0] |= cached_has_bits;
472 }
473 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
474 }
475
CopyFrom(const I2cReadFtraceEvent & from)476 void I2cReadFtraceEvent::CopyFrom(const I2cReadFtraceEvent& from) {
477 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.I2cReadFtraceEvent)
478 if (&from == this) return;
479 Clear();
480 MergeFrom(from);
481 }
482
IsInitialized() const483 bool I2cReadFtraceEvent::IsInitialized() const {
484 return true;
485 }
486
InternalSwap(I2cReadFtraceEvent * other)487 void I2cReadFtraceEvent::InternalSwap(I2cReadFtraceEvent* other) {
488 using std::swap;
489 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
490 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
491 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
492 PROTOBUF_FIELD_OFFSET(I2cReadFtraceEvent, _impl_.len_)
493 + sizeof(I2cReadFtraceEvent::_impl_.len_) // NOLINT
494 - PROTOBUF_FIELD_OFFSET(I2cReadFtraceEvent, _impl_.adapter_nr_)>(
495 reinterpret_cast<char*>(&_impl_.adapter_nr_),
496 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
497 }
498
GetTypeName() const499 std::string I2cReadFtraceEvent::GetTypeName() const {
500 return "perfetto.protos.I2cReadFtraceEvent";
501 }
502
503
504 // ===================================================================
505
506 class I2cWriteFtraceEvent::_Internal {
507 public:
508 using HasBits = decltype(std::declval<I2cWriteFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)509 static void set_has_adapter_nr(HasBits* has_bits) {
510 (*has_bits)[0] |= 1u;
511 }
set_has_msg_nr(HasBits * has_bits)512 static void set_has_msg_nr(HasBits* has_bits) {
513 (*has_bits)[0] |= 2u;
514 }
set_has_addr(HasBits * has_bits)515 static void set_has_addr(HasBits* has_bits) {
516 (*has_bits)[0] |= 4u;
517 }
set_has_flags(HasBits * has_bits)518 static void set_has_flags(HasBits* has_bits) {
519 (*has_bits)[0] |= 8u;
520 }
set_has_len(HasBits * has_bits)521 static void set_has_len(HasBits* has_bits) {
522 (*has_bits)[0] |= 16u;
523 }
set_has_buf(HasBits * has_bits)524 static void set_has_buf(HasBits* has_bits) {
525 (*has_bits)[0] |= 32u;
526 }
527 };
528
I2cWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)529 I2cWriteFtraceEvent::I2cWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
530 bool is_message_owned)
531 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
532 SharedCtor(arena, is_message_owned);
533 // @@protoc_insertion_point(arena_constructor:perfetto.protos.I2cWriteFtraceEvent)
534 }
I2cWriteFtraceEvent(const I2cWriteFtraceEvent & from)535 I2cWriteFtraceEvent::I2cWriteFtraceEvent(const I2cWriteFtraceEvent& from)
536 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
537 I2cWriteFtraceEvent* const _this = this; (void)_this;
538 new (&_impl_) Impl_{
539 decltype(_impl_._has_bits_){from._impl_._has_bits_}
540 , /*decltype(_impl_._cached_size_)*/{}
541 , decltype(_impl_.adapter_nr_){}
542 , decltype(_impl_.msg_nr_){}
543 , decltype(_impl_.addr_){}
544 , decltype(_impl_.flags_){}
545 , decltype(_impl_.len_){}
546 , decltype(_impl_.buf_){}};
547
548 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
549 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
550 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.buf_) -
551 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.buf_));
552 // @@protoc_insertion_point(copy_constructor:perfetto.protos.I2cWriteFtraceEvent)
553 }
554
SharedCtor(::_pb::Arena * arena,bool is_message_owned)555 inline void I2cWriteFtraceEvent::SharedCtor(
556 ::_pb::Arena* arena, bool is_message_owned) {
557 (void)arena;
558 (void)is_message_owned;
559 new (&_impl_) Impl_{
560 decltype(_impl_._has_bits_){}
561 , /*decltype(_impl_._cached_size_)*/{}
562 , decltype(_impl_.adapter_nr_){0}
563 , decltype(_impl_.msg_nr_){0u}
564 , decltype(_impl_.addr_){0u}
565 , decltype(_impl_.flags_){0u}
566 , decltype(_impl_.len_){0u}
567 , decltype(_impl_.buf_){0u}
568 };
569 }
570
~I2cWriteFtraceEvent()571 I2cWriteFtraceEvent::~I2cWriteFtraceEvent() {
572 // @@protoc_insertion_point(destructor:perfetto.protos.I2cWriteFtraceEvent)
573 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
574 (void)arena;
575 return;
576 }
577 SharedDtor();
578 }
579
SharedDtor()580 inline void I2cWriteFtraceEvent::SharedDtor() {
581 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
582 }
583
SetCachedSize(int size) const584 void I2cWriteFtraceEvent::SetCachedSize(int size) const {
585 _impl_._cached_size_.Set(size);
586 }
587
Clear()588 void I2cWriteFtraceEvent::Clear() {
589 // @@protoc_insertion_point(message_clear_start:perfetto.protos.I2cWriteFtraceEvent)
590 ::uint32_t cached_has_bits = 0;
591 // Prevent compiler warnings about cached_has_bits being unused
592 (void) cached_has_bits;
593
594 cached_has_bits = _impl_._has_bits_[0];
595 if (cached_has_bits & 0x0000003fu) {
596 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
597 reinterpret_cast<char*>(&_impl_.buf_) -
598 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.buf_));
599 }
600 _impl_._has_bits_.Clear();
601 _internal_metadata_.Clear<std::string>();
602 }
603
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)604 const char* I2cWriteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
605 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
606 _Internal::HasBits has_bits{};
607 while (!ctx->Done(&ptr)) {
608 ::uint32_t tag;
609 ptr = ::_pbi::ReadTag(ptr, &tag);
610 switch (tag >> 3) {
611 // optional int32 adapter_nr = 1;
612 case 1:
613 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
614 _Internal::set_has_adapter_nr(&has_bits);
615 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
616 CHK_(ptr);
617 } else {
618 goto handle_unusual;
619 }
620 continue;
621 // optional uint32 msg_nr = 2;
622 case 2:
623 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
624 _Internal::set_has_msg_nr(&has_bits);
625 _impl_.msg_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
626 CHK_(ptr);
627 } else {
628 goto handle_unusual;
629 }
630 continue;
631 // optional uint32 addr = 3;
632 case 3:
633 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
634 _Internal::set_has_addr(&has_bits);
635 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
636 CHK_(ptr);
637 } else {
638 goto handle_unusual;
639 }
640 continue;
641 // optional uint32 flags = 4;
642 case 4:
643 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
644 _Internal::set_has_flags(&has_bits);
645 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
646 CHK_(ptr);
647 } else {
648 goto handle_unusual;
649 }
650 continue;
651 // optional uint32 len = 5;
652 case 5:
653 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
654 _Internal::set_has_len(&has_bits);
655 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
656 CHK_(ptr);
657 } else {
658 goto handle_unusual;
659 }
660 continue;
661 // optional uint32 buf = 6;
662 case 6:
663 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
664 _Internal::set_has_buf(&has_bits);
665 _impl_.buf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
666 CHK_(ptr);
667 } else {
668 goto handle_unusual;
669 }
670 continue;
671 default:
672 goto handle_unusual;
673 } // switch
674 handle_unusual:
675 if ((tag == 0) || ((tag & 7) == 4)) {
676 CHK_(ptr);
677 ctx->SetLastTag(tag);
678 goto message_done;
679 }
680 ptr = UnknownFieldParse(
681 tag,
682 _internal_metadata_.mutable_unknown_fields<std::string>(),
683 ptr, ctx);
684 CHK_(ptr != nullptr);
685 } // while
686 message_done:
687 _impl_._has_bits_.Or(has_bits);
688 return ptr;
689 failure:
690 ptr = nullptr;
691 goto message_done;
692 #undef CHK_
693 }
694
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const695 ::uint8_t* I2cWriteFtraceEvent::_InternalSerialize(
696 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
697 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.I2cWriteFtraceEvent)
698 ::uint32_t cached_has_bits = 0;
699 (void) cached_has_bits;
700
701 cached_has_bits = _impl_._has_bits_[0];
702 // optional int32 adapter_nr = 1;
703 if (cached_has_bits & 0x00000001u) {
704 target = stream->EnsureSpace(target);
705 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
706 }
707
708 // optional uint32 msg_nr = 2;
709 if (cached_has_bits & 0x00000002u) {
710 target = stream->EnsureSpace(target);
711 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_msg_nr(), target);
712 }
713
714 // optional uint32 addr = 3;
715 if (cached_has_bits & 0x00000004u) {
716 target = stream->EnsureSpace(target);
717 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_addr(), target);
718 }
719
720 // optional uint32 flags = 4;
721 if (cached_has_bits & 0x00000008u) {
722 target = stream->EnsureSpace(target);
723 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_flags(), target);
724 }
725
726 // optional uint32 len = 5;
727 if (cached_has_bits & 0x00000010u) {
728 target = stream->EnsureSpace(target);
729 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_len(), target);
730 }
731
732 // optional uint32 buf = 6;
733 if (cached_has_bits & 0x00000020u) {
734 target = stream->EnsureSpace(target);
735 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_buf(), target);
736 }
737
738 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
739 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
740 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
741 }
742 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.I2cWriteFtraceEvent)
743 return target;
744 }
745
ByteSizeLong() const746 size_t I2cWriteFtraceEvent::ByteSizeLong() const {
747 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.I2cWriteFtraceEvent)
748 size_t total_size = 0;
749
750 ::uint32_t cached_has_bits = 0;
751 // Prevent compiler warnings about cached_has_bits being unused
752 (void) cached_has_bits;
753
754 cached_has_bits = _impl_._has_bits_[0];
755 if (cached_has_bits & 0x0000003fu) {
756 // optional int32 adapter_nr = 1;
757 if (cached_has_bits & 0x00000001u) {
758 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
759 }
760
761 // optional uint32 msg_nr = 2;
762 if (cached_has_bits & 0x00000002u) {
763 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_msg_nr());
764 }
765
766 // optional uint32 addr = 3;
767 if (cached_has_bits & 0x00000004u) {
768 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
769 }
770
771 // optional uint32 flags = 4;
772 if (cached_has_bits & 0x00000008u) {
773 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
774 }
775
776 // optional uint32 len = 5;
777 if (cached_has_bits & 0x00000010u) {
778 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
779 }
780
781 // optional uint32 buf = 6;
782 if (cached_has_bits & 0x00000020u) {
783 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_buf());
784 }
785
786 }
787 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
788 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
789 }
790 int cached_size = ::_pbi::ToCachedSize(total_size);
791 SetCachedSize(cached_size);
792 return total_size;
793 }
794
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)795 void I2cWriteFtraceEvent::CheckTypeAndMergeFrom(
796 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
797 MergeFrom(*::_pbi::DownCast<const I2cWriteFtraceEvent*>(
798 &from));
799 }
800
MergeFrom(const I2cWriteFtraceEvent & from)801 void I2cWriteFtraceEvent::MergeFrom(const I2cWriteFtraceEvent& from) {
802 I2cWriteFtraceEvent* const _this = this;
803 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.I2cWriteFtraceEvent)
804 GOOGLE_DCHECK_NE(&from, _this);
805 ::uint32_t cached_has_bits = 0;
806 (void) cached_has_bits;
807
808 cached_has_bits = from._impl_._has_bits_[0];
809 if (cached_has_bits & 0x0000003fu) {
810 if (cached_has_bits & 0x00000001u) {
811 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
812 }
813 if (cached_has_bits & 0x00000002u) {
814 _this->_impl_.msg_nr_ = from._impl_.msg_nr_;
815 }
816 if (cached_has_bits & 0x00000004u) {
817 _this->_impl_.addr_ = from._impl_.addr_;
818 }
819 if (cached_has_bits & 0x00000008u) {
820 _this->_impl_.flags_ = from._impl_.flags_;
821 }
822 if (cached_has_bits & 0x00000010u) {
823 _this->_impl_.len_ = from._impl_.len_;
824 }
825 if (cached_has_bits & 0x00000020u) {
826 _this->_impl_.buf_ = from._impl_.buf_;
827 }
828 _this->_impl_._has_bits_[0] |= cached_has_bits;
829 }
830 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
831 }
832
CopyFrom(const I2cWriteFtraceEvent & from)833 void I2cWriteFtraceEvent::CopyFrom(const I2cWriteFtraceEvent& from) {
834 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.I2cWriteFtraceEvent)
835 if (&from == this) return;
836 Clear();
837 MergeFrom(from);
838 }
839
IsInitialized() const840 bool I2cWriteFtraceEvent::IsInitialized() const {
841 return true;
842 }
843
InternalSwap(I2cWriteFtraceEvent * other)844 void I2cWriteFtraceEvent::InternalSwap(I2cWriteFtraceEvent* other) {
845 using std::swap;
846 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
847 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
848 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
849 PROTOBUF_FIELD_OFFSET(I2cWriteFtraceEvent, _impl_.buf_)
850 + sizeof(I2cWriteFtraceEvent::_impl_.buf_) // NOLINT
851 - PROTOBUF_FIELD_OFFSET(I2cWriteFtraceEvent, _impl_.adapter_nr_)>(
852 reinterpret_cast<char*>(&_impl_.adapter_nr_),
853 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
854 }
855
GetTypeName() const856 std::string I2cWriteFtraceEvent::GetTypeName() const {
857 return "perfetto.protos.I2cWriteFtraceEvent";
858 }
859
860
861 // ===================================================================
862
863 class I2cResultFtraceEvent::_Internal {
864 public:
865 using HasBits = decltype(std::declval<I2cResultFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)866 static void set_has_adapter_nr(HasBits* has_bits) {
867 (*has_bits)[0] |= 1u;
868 }
set_has_nr_msgs(HasBits * has_bits)869 static void set_has_nr_msgs(HasBits* has_bits) {
870 (*has_bits)[0] |= 2u;
871 }
set_has_ret(HasBits * has_bits)872 static void set_has_ret(HasBits* has_bits) {
873 (*has_bits)[0] |= 4u;
874 }
875 };
876
I2cResultFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)877 I2cResultFtraceEvent::I2cResultFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
878 bool is_message_owned)
879 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
880 SharedCtor(arena, is_message_owned);
881 // @@protoc_insertion_point(arena_constructor:perfetto.protos.I2cResultFtraceEvent)
882 }
I2cResultFtraceEvent(const I2cResultFtraceEvent & from)883 I2cResultFtraceEvent::I2cResultFtraceEvent(const I2cResultFtraceEvent& from)
884 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
885 I2cResultFtraceEvent* const _this = this; (void)_this;
886 new (&_impl_) Impl_{
887 decltype(_impl_._has_bits_){from._impl_._has_bits_}
888 , /*decltype(_impl_._cached_size_)*/{}
889 , decltype(_impl_.adapter_nr_){}
890 , decltype(_impl_.nr_msgs_){}
891 , decltype(_impl_.ret_){}};
892
893 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
894 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
895 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ret_) -
896 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.ret_));
897 // @@protoc_insertion_point(copy_constructor:perfetto.protos.I2cResultFtraceEvent)
898 }
899
SharedCtor(::_pb::Arena * arena,bool is_message_owned)900 inline void I2cResultFtraceEvent::SharedCtor(
901 ::_pb::Arena* arena, bool is_message_owned) {
902 (void)arena;
903 (void)is_message_owned;
904 new (&_impl_) Impl_{
905 decltype(_impl_._has_bits_){}
906 , /*decltype(_impl_._cached_size_)*/{}
907 , decltype(_impl_.adapter_nr_){0}
908 , decltype(_impl_.nr_msgs_){0u}
909 , decltype(_impl_.ret_){0}
910 };
911 }
912
~I2cResultFtraceEvent()913 I2cResultFtraceEvent::~I2cResultFtraceEvent() {
914 // @@protoc_insertion_point(destructor:perfetto.protos.I2cResultFtraceEvent)
915 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
916 (void)arena;
917 return;
918 }
919 SharedDtor();
920 }
921
SharedDtor()922 inline void I2cResultFtraceEvent::SharedDtor() {
923 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
924 }
925
SetCachedSize(int size) const926 void I2cResultFtraceEvent::SetCachedSize(int size) const {
927 _impl_._cached_size_.Set(size);
928 }
929
Clear()930 void I2cResultFtraceEvent::Clear() {
931 // @@protoc_insertion_point(message_clear_start:perfetto.protos.I2cResultFtraceEvent)
932 ::uint32_t cached_has_bits = 0;
933 // Prevent compiler warnings about cached_has_bits being unused
934 (void) cached_has_bits;
935
936 cached_has_bits = _impl_._has_bits_[0];
937 if (cached_has_bits & 0x00000007u) {
938 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
939 reinterpret_cast<char*>(&_impl_.ret_) -
940 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.ret_));
941 }
942 _impl_._has_bits_.Clear();
943 _internal_metadata_.Clear<std::string>();
944 }
945
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)946 const char* I2cResultFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
947 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
948 _Internal::HasBits has_bits{};
949 while (!ctx->Done(&ptr)) {
950 ::uint32_t tag;
951 ptr = ::_pbi::ReadTag(ptr, &tag);
952 switch (tag >> 3) {
953 // optional int32 adapter_nr = 1;
954 case 1:
955 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
956 _Internal::set_has_adapter_nr(&has_bits);
957 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
958 CHK_(ptr);
959 } else {
960 goto handle_unusual;
961 }
962 continue;
963 // optional uint32 nr_msgs = 2;
964 case 2:
965 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
966 _Internal::set_has_nr_msgs(&has_bits);
967 _impl_.nr_msgs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
968 CHK_(ptr);
969 } else {
970 goto handle_unusual;
971 }
972 continue;
973 // optional int32 ret = 3;
974 case 3:
975 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
976 _Internal::set_has_ret(&has_bits);
977 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
978 CHK_(ptr);
979 } else {
980 goto handle_unusual;
981 }
982 continue;
983 default:
984 goto handle_unusual;
985 } // switch
986 handle_unusual:
987 if ((tag == 0) || ((tag & 7) == 4)) {
988 CHK_(ptr);
989 ctx->SetLastTag(tag);
990 goto message_done;
991 }
992 ptr = UnknownFieldParse(
993 tag,
994 _internal_metadata_.mutable_unknown_fields<std::string>(),
995 ptr, ctx);
996 CHK_(ptr != nullptr);
997 } // while
998 message_done:
999 _impl_._has_bits_.Or(has_bits);
1000 return ptr;
1001 failure:
1002 ptr = nullptr;
1003 goto message_done;
1004 #undef CHK_
1005 }
1006
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1007 ::uint8_t* I2cResultFtraceEvent::_InternalSerialize(
1008 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1009 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.I2cResultFtraceEvent)
1010 ::uint32_t cached_has_bits = 0;
1011 (void) cached_has_bits;
1012
1013 cached_has_bits = _impl_._has_bits_[0];
1014 // optional int32 adapter_nr = 1;
1015 if (cached_has_bits & 0x00000001u) {
1016 target = stream->EnsureSpace(target);
1017 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
1018 }
1019
1020 // optional uint32 nr_msgs = 2;
1021 if (cached_has_bits & 0x00000002u) {
1022 target = stream->EnsureSpace(target);
1023 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_nr_msgs(), target);
1024 }
1025
1026 // optional int32 ret = 3;
1027 if (cached_has_bits & 0x00000004u) {
1028 target = stream->EnsureSpace(target);
1029 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_ret(), target);
1030 }
1031
1032 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1033 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1034 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1035 }
1036 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.I2cResultFtraceEvent)
1037 return target;
1038 }
1039
ByteSizeLong() const1040 size_t I2cResultFtraceEvent::ByteSizeLong() const {
1041 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.I2cResultFtraceEvent)
1042 size_t total_size = 0;
1043
1044 ::uint32_t cached_has_bits = 0;
1045 // Prevent compiler warnings about cached_has_bits being unused
1046 (void) cached_has_bits;
1047
1048 cached_has_bits = _impl_._has_bits_[0];
1049 if (cached_has_bits & 0x00000007u) {
1050 // optional int32 adapter_nr = 1;
1051 if (cached_has_bits & 0x00000001u) {
1052 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
1053 }
1054
1055 // optional uint32 nr_msgs = 2;
1056 if (cached_has_bits & 0x00000002u) {
1057 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_msgs());
1058 }
1059
1060 // optional int32 ret = 3;
1061 if (cached_has_bits & 0x00000004u) {
1062 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
1063 }
1064
1065 }
1066 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1067 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1068 }
1069 int cached_size = ::_pbi::ToCachedSize(total_size);
1070 SetCachedSize(cached_size);
1071 return total_size;
1072 }
1073
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1074 void I2cResultFtraceEvent::CheckTypeAndMergeFrom(
1075 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1076 MergeFrom(*::_pbi::DownCast<const I2cResultFtraceEvent*>(
1077 &from));
1078 }
1079
MergeFrom(const I2cResultFtraceEvent & from)1080 void I2cResultFtraceEvent::MergeFrom(const I2cResultFtraceEvent& from) {
1081 I2cResultFtraceEvent* const _this = this;
1082 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.I2cResultFtraceEvent)
1083 GOOGLE_DCHECK_NE(&from, _this);
1084 ::uint32_t cached_has_bits = 0;
1085 (void) cached_has_bits;
1086
1087 cached_has_bits = from._impl_._has_bits_[0];
1088 if (cached_has_bits & 0x00000007u) {
1089 if (cached_has_bits & 0x00000001u) {
1090 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
1091 }
1092 if (cached_has_bits & 0x00000002u) {
1093 _this->_impl_.nr_msgs_ = from._impl_.nr_msgs_;
1094 }
1095 if (cached_has_bits & 0x00000004u) {
1096 _this->_impl_.ret_ = from._impl_.ret_;
1097 }
1098 _this->_impl_._has_bits_[0] |= cached_has_bits;
1099 }
1100 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1101 }
1102
CopyFrom(const I2cResultFtraceEvent & from)1103 void I2cResultFtraceEvent::CopyFrom(const I2cResultFtraceEvent& from) {
1104 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.I2cResultFtraceEvent)
1105 if (&from == this) return;
1106 Clear();
1107 MergeFrom(from);
1108 }
1109
IsInitialized() const1110 bool I2cResultFtraceEvent::IsInitialized() const {
1111 return true;
1112 }
1113
InternalSwap(I2cResultFtraceEvent * other)1114 void I2cResultFtraceEvent::InternalSwap(I2cResultFtraceEvent* other) {
1115 using std::swap;
1116 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1117 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1118 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1119 PROTOBUF_FIELD_OFFSET(I2cResultFtraceEvent, _impl_.ret_)
1120 + sizeof(I2cResultFtraceEvent::_impl_.ret_) // NOLINT
1121 - PROTOBUF_FIELD_OFFSET(I2cResultFtraceEvent, _impl_.adapter_nr_)>(
1122 reinterpret_cast<char*>(&_impl_.adapter_nr_),
1123 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
1124 }
1125
GetTypeName() const1126 std::string I2cResultFtraceEvent::GetTypeName() const {
1127 return "perfetto.protos.I2cResultFtraceEvent";
1128 }
1129
1130
1131 // ===================================================================
1132
1133 class I2cReplyFtraceEvent::_Internal {
1134 public:
1135 using HasBits = decltype(std::declval<I2cReplyFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)1136 static void set_has_adapter_nr(HasBits* has_bits) {
1137 (*has_bits)[0] |= 1u;
1138 }
set_has_msg_nr(HasBits * has_bits)1139 static void set_has_msg_nr(HasBits* has_bits) {
1140 (*has_bits)[0] |= 2u;
1141 }
set_has_addr(HasBits * has_bits)1142 static void set_has_addr(HasBits* has_bits) {
1143 (*has_bits)[0] |= 4u;
1144 }
set_has_flags(HasBits * has_bits)1145 static void set_has_flags(HasBits* has_bits) {
1146 (*has_bits)[0] |= 8u;
1147 }
set_has_len(HasBits * has_bits)1148 static void set_has_len(HasBits* has_bits) {
1149 (*has_bits)[0] |= 16u;
1150 }
set_has_buf(HasBits * has_bits)1151 static void set_has_buf(HasBits* has_bits) {
1152 (*has_bits)[0] |= 32u;
1153 }
1154 };
1155
I2cReplyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1156 I2cReplyFtraceEvent::I2cReplyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1157 bool is_message_owned)
1158 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1159 SharedCtor(arena, is_message_owned);
1160 // @@protoc_insertion_point(arena_constructor:perfetto.protos.I2cReplyFtraceEvent)
1161 }
I2cReplyFtraceEvent(const I2cReplyFtraceEvent & from)1162 I2cReplyFtraceEvent::I2cReplyFtraceEvent(const I2cReplyFtraceEvent& from)
1163 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1164 I2cReplyFtraceEvent* const _this = this; (void)_this;
1165 new (&_impl_) Impl_{
1166 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1167 , /*decltype(_impl_._cached_size_)*/{}
1168 , decltype(_impl_.adapter_nr_){}
1169 , decltype(_impl_.msg_nr_){}
1170 , decltype(_impl_.addr_){}
1171 , decltype(_impl_.flags_){}
1172 , decltype(_impl_.len_){}
1173 , decltype(_impl_.buf_){}};
1174
1175 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1176 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
1177 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.buf_) -
1178 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.buf_));
1179 // @@protoc_insertion_point(copy_constructor:perfetto.protos.I2cReplyFtraceEvent)
1180 }
1181
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1182 inline void I2cReplyFtraceEvent::SharedCtor(
1183 ::_pb::Arena* arena, bool is_message_owned) {
1184 (void)arena;
1185 (void)is_message_owned;
1186 new (&_impl_) Impl_{
1187 decltype(_impl_._has_bits_){}
1188 , /*decltype(_impl_._cached_size_)*/{}
1189 , decltype(_impl_.adapter_nr_){0}
1190 , decltype(_impl_.msg_nr_){0u}
1191 , decltype(_impl_.addr_){0u}
1192 , decltype(_impl_.flags_){0u}
1193 , decltype(_impl_.len_){0u}
1194 , decltype(_impl_.buf_){0u}
1195 };
1196 }
1197
~I2cReplyFtraceEvent()1198 I2cReplyFtraceEvent::~I2cReplyFtraceEvent() {
1199 // @@protoc_insertion_point(destructor:perfetto.protos.I2cReplyFtraceEvent)
1200 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1201 (void)arena;
1202 return;
1203 }
1204 SharedDtor();
1205 }
1206
SharedDtor()1207 inline void I2cReplyFtraceEvent::SharedDtor() {
1208 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1209 }
1210
SetCachedSize(int size) const1211 void I2cReplyFtraceEvent::SetCachedSize(int size) const {
1212 _impl_._cached_size_.Set(size);
1213 }
1214
Clear()1215 void I2cReplyFtraceEvent::Clear() {
1216 // @@protoc_insertion_point(message_clear_start:perfetto.protos.I2cReplyFtraceEvent)
1217 ::uint32_t cached_has_bits = 0;
1218 // Prevent compiler warnings about cached_has_bits being unused
1219 (void) cached_has_bits;
1220
1221 cached_has_bits = _impl_._has_bits_[0];
1222 if (cached_has_bits & 0x0000003fu) {
1223 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
1224 reinterpret_cast<char*>(&_impl_.buf_) -
1225 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.buf_));
1226 }
1227 _impl_._has_bits_.Clear();
1228 _internal_metadata_.Clear<std::string>();
1229 }
1230
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1231 const char* I2cReplyFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1232 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1233 _Internal::HasBits has_bits{};
1234 while (!ctx->Done(&ptr)) {
1235 ::uint32_t tag;
1236 ptr = ::_pbi::ReadTag(ptr, &tag);
1237 switch (tag >> 3) {
1238 // optional int32 adapter_nr = 1;
1239 case 1:
1240 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1241 _Internal::set_has_adapter_nr(&has_bits);
1242 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1243 CHK_(ptr);
1244 } else {
1245 goto handle_unusual;
1246 }
1247 continue;
1248 // optional uint32 msg_nr = 2;
1249 case 2:
1250 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1251 _Internal::set_has_msg_nr(&has_bits);
1252 _impl_.msg_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1253 CHK_(ptr);
1254 } else {
1255 goto handle_unusual;
1256 }
1257 continue;
1258 // optional uint32 addr = 3;
1259 case 3:
1260 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1261 _Internal::set_has_addr(&has_bits);
1262 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1263 CHK_(ptr);
1264 } else {
1265 goto handle_unusual;
1266 }
1267 continue;
1268 // optional uint32 flags = 4;
1269 case 4:
1270 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1271 _Internal::set_has_flags(&has_bits);
1272 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1273 CHK_(ptr);
1274 } else {
1275 goto handle_unusual;
1276 }
1277 continue;
1278 // optional uint32 len = 5;
1279 case 5:
1280 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1281 _Internal::set_has_len(&has_bits);
1282 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1283 CHK_(ptr);
1284 } else {
1285 goto handle_unusual;
1286 }
1287 continue;
1288 // optional uint32 buf = 6;
1289 case 6:
1290 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1291 _Internal::set_has_buf(&has_bits);
1292 _impl_.buf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1293 CHK_(ptr);
1294 } else {
1295 goto handle_unusual;
1296 }
1297 continue;
1298 default:
1299 goto handle_unusual;
1300 } // switch
1301 handle_unusual:
1302 if ((tag == 0) || ((tag & 7) == 4)) {
1303 CHK_(ptr);
1304 ctx->SetLastTag(tag);
1305 goto message_done;
1306 }
1307 ptr = UnknownFieldParse(
1308 tag,
1309 _internal_metadata_.mutable_unknown_fields<std::string>(),
1310 ptr, ctx);
1311 CHK_(ptr != nullptr);
1312 } // while
1313 message_done:
1314 _impl_._has_bits_.Or(has_bits);
1315 return ptr;
1316 failure:
1317 ptr = nullptr;
1318 goto message_done;
1319 #undef CHK_
1320 }
1321
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1322 ::uint8_t* I2cReplyFtraceEvent::_InternalSerialize(
1323 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1324 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.I2cReplyFtraceEvent)
1325 ::uint32_t cached_has_bits = 0;
1326 (void) cached_has_bits;
1327
1328 cached_has_bits = _impl_._has_bits_[0];
1329 // optional int32 adapter_nr = 1;
1330 if (cached_has_bits & 0x00000001u) {
1331 target = stream->EnsureSpace(target);
1332 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
1333 }
1334
1335 // optional uint32 msg_nr = 2;
1336 if (cached_has_bits & 0x00000002u) {
1337 target = stream->EnsureSpace(target);
1338 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_msg_nr(), target);
1339 }
1340
1341 // optional uint32 addr = 3;
1342 if (cached_has_bits & 0x00000004u) {
1343 target = stream->EnsureSpace(target);
1344 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_addr(), target);
1345 }
1346
1347 // optional uint32 flags = 4;
1348 if (cached_has_bits & 0x00000008u) {
1349 target = stream->EnsureSpace(target);
1350 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_flags(), target);
1351 }
1352
1353 // optional uint32 len = 5;
1354 if (cached_has_bits & 0x00000010u) {
1355 target = stream->EnsureSpace(target);
1356 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_len(), target);
1357 }
1358
1359 // optional uint32 buf = 6;
1360 if (cached_has_bits & 0x00000020u) {
1361 target = stream->EnsureSpace(target);
1362 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_buf(), target);
1363 }
1364
1365 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1366 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1367 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1368 }
1369 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.I2cReplyFtraceEvent)
1370 return target;
1371 }
1372
ByteSizeLong() const1373 size_t I2cReplyFtraceEvent::ByteSizeLong() const {
1374 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.I2cReplyFtraceEvent)
1375 size_t total_size = 0;
1376
1377 ::uint32_t cached_has_bits = 0;
1378 // Prevent compiler warnings about cached_has_bits being unused
1379 (void) cached_has_bits;
1380
1381 cached_has_bits = _impl_._has_bits_[0];
1382 if (cached_has_bits & 0x0000003fu) {
1383 // optional int32 adapter_nr = 1;
1384 if (cached_has_bits & 0x00000001u) {
1385 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
1386 }
1387
1388 // optional uint32 msg_nr = 2;
1389 if (cached_has_bits & 0x00000002u) {
1390 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_msg_nr());
1391 }
1392
1393 // optional uint32 addr = 3;
1394 if (cached_has_bits & 0x00000004u) {
1395 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
1396 }
1397
1398 // optional uint32 flags = 4;
1399 if (cached_has_bits & 0x00000008u) {
1400 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
1401 }
1402
1403 // optional uint32 len = 5;
1404 if (cached_has_bits & 0x00000010u) {
1405 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
1406 }
1407
1408 // optional uint32 buf = 6;
1409 if (cached_has_bits & 0x00000020u) {
1410 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_buf());
1411 }
1412
1413 }
1414 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1415 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1416 }
1417 int cached_size = ::_pbi::ToCachedSize(total_size);
1418 SetCachedSize(cached_size);
1419 return total_size;
1420 }
1421
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1422 void I2cReplyFtraceEvent::CheckTypeAndMergeFrom(
1423 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1424 MergeFrom(*::_pbi::DownCast<const I2cReplyFtraceEvent*>(
1425 &from));
1426 }
1427
MergeFrom(const I2cReplyFtraceEvent & from)1428 void I2cReplyFtraceEvent::MergeFrom(const I2cReplyFtraceEvent& from) {
1429 I2cReplyFtraceEvent* const _this = this;
1430 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.I2cReplyFtraceEvent)
1431 GOOGLE_DCHECK_NE(&from, _this);
1432 ::uint32_t cached_has_bits = 0;
1433 (void) cached_has_bits;
1434
1435 cached_has_bits = from._impl_._has_bits_[0];
1436 if (cached_has_bits & 0x0000003fu) {
1437 if (cached_has_bits & 0x00000001u) {
1438 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
1439 }
1440 if (cached_has_bits & 0x00000002u) {
1441 _this->_impl_.msg_nr_ = from._impl_.msg_nr_;
1442 }
1443 if (cached_has_bits & 0x00000004u) {
1444 _this->_impl_.addr_ = from._impl_.addr_;
1445 }
1446 if (cached_has_bits & 0x00000008u) {
1447 _this->_impl_.flags_ = from._impl_.flags_;
1448 }
1449 if (cached_has_bits & 0x00000010u) {
1450 _this->_impl_.len_ = from._impl_.len_;
1451 }
1452 if (cached_has_bits & 0x00000020u) {
1453 _this->_impl_.buf_ = from._impl_.buf_;
1454 }
1455 _this->_impl_._has_bits_[0] |= cached_has_bits;
1456 }
1457 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1458 }
1459
CopyFrom(const I2cReplyFtraceEvent & from)1460 void I2cReplyFtraceEvent::CopyFrom(const I2cReplyFtraceEvent& from) {
1461 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.I2cReplyFtraceEvent)
1462 if (&from == this) return;
1463 Clear();
1464 MergeFrom(from);
1465 }
1466
IsInitialized() const1467 bool I2cReplyFtraceEvent::IsInitialized() const {
1468 return true;
1469 }
1470
InternalSwap(I2cReplyFtraceEvent * other)1471 void I2cReplyFtraceEvent::InternalSwap(I2cReplyFtraceEvent* other) {
1472 using std::swap;
1473 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1474 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1475 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1476 PROTOBUF_FIELD_OFFSET(I2cReplyFtraceEvent, _impl_.buf_)
1477 + sizeof(I2cReplyFtraceEvent::_impl_.buf_) // NOLINT
1478 - PROTOBUF_FIELD_OFFSET(I2cReplyFtraceEvent, _impl_.adapter_nr_)>(
1479 reinterpret_cast<char*>(&_impl_.adapter_nr_),
1480 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
1481 }
1482
GetTypeName() const1483 std::string I2cReplyFtraceEvent::GetTypeName() const {
1484 return "perfetto.protos.I2cReplyFtraceEvent";
1485 }
1486
1487
1488 // ===================================================================
1489
1490 class SmbusReadFtraceEvent::_Internal {
1491 public:
1492 using HasBits = decltype(std::declval<SmbusReadFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)1493 static void set_has_adapter_nr(HasBits* has_bits) {
1494 (*has_bits)[0] |= 1u;
1495 }
set_has_flags(HasBits * has_bits)1496 static void set_has_flags(HasBits* has_bits) {
1497 (*has_bits)[0] |= 2u;
1498 }
set_has_addr(HasBits * has_bits)1499 static void set_has_addr(HasBits* has_bits) {
1500 (*has_bits)[0] |= 4u;
1501 }
set_has_command(HasBits * has_bits)1502 static void set_has_command(HasBits* has_bits) {
1503 (*has_bits)[0] |= 8u;
1504 }
set_has_protocol(HasBits * has_bits)1505 static void set_has_protocol(HasBits* has_bits) {
1506 (*has_bits)[0] |= 16u;
1507 }
1508 };
1509
SmbusReadFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1510 SmbusReadFtraceEvent::SmbusReadFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1511 bool is_message_owned)
1512 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1513 SharedCtor(arena, is_message_owned);
1514 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SmbusReadFtraceEvent)
1515 }
SmbusReadFtraceEvent(const SmbusReadFtraceEvent & from)1516 SmbusReadFtraceEvent::SmbusReadFtraceEvent(const SmbusReadFtraceEvent& from)
1517 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1518 SmbusReadFtraceEvent* const _this = this; (void)_this;
1519 new (&_impl_) Impl_{
1520 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1521 , /*decltype(_impl_._cached_size_)*/{}
1522 , decltype(_impl_.adapter_nr_){}
1523 , decltype(_impl_.flags_){}
1524 , decltype(_impl_.addr_){}
1525 , decltype(_impl_.command_){}
1526 , decltype(_impl_.protocol_){}};
1527
1528 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1529 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
1530 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.protocol_) -
1531 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
1532 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SmbusReadFtraceEvent)
1533 }
1534
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1535 inline void SmbusReadFtraceEvent::SharedCtor(
1536 ::_pb::Arena* arena, bool is_message_owned) {
1537 (void)arena;
1538 (void)is_message_owned;
1539 new (&_impl_) Impl_{
1540 decltype(_impl_._has_bits_){}
1541 , /*decltype(_impl_._cached_size_)*/{}
1542 , decltype(_impl_.adapter_nr_){0}
1543 , decltype(_impl_.flags_){0u}
1544 , decltype(_impl_.addr_){0u}
1545 , decltype(_impl_.command_){0u}
1546 , decltype(_impl_.protocol_){0u}
1547 };
1548 }
1549
~SmbusReadFtraceEvent()1550 SmbusReadFtraceEvent::~SmbusReadFtraceEvent() {
1551 // @@protoc_insertion_point(destructor:perfetto.protos.SmbusReadFtraceEvent)
1552 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1553 (void)arena;
1554 return;
1555 }
1556 SharedDtor();
1557 }
1558
SharedDtor()1559 inline void SmbusReadFtraceEvent::SharedDtor() {
1560 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1561 }
1562
SetCachedSize(int size) const1563 void SmbusReadFtraceEvent::SetCachedSize(int size) const {
1564 _impl_._cached_size_.Set(size);
1565 }
1566
Clear()1567 void SmbusReadFtraceEvent::Clear() {
1568 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SmbusReadFtraceEvent)
1569 ::uint32_t cached_has_bits = 0;
1570 // Prevent compiler warnings about cached_has_bits being unused
1571 (void) cached_has_bits;
1572
1573 cached_has_bits = _impl_._has_bits_[0];
1574 if (cached_has_bits & 0x0000001fu) {
1575 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
1576 reinterpret_cast<char*>(&_impl_.protocol_) -
1577 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
1578 }
1579 _impl_._has_bits_.Clear();
1580 _internal_metadata_.Clear<std::string>();
1581 }
1582
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1583 const char* SmbusReadFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1584 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1585 _Internal::HasBits has_bits{};
1586 while (!ctx->Done(&ptr)) {
1587 ::uint32_t tag;
1588 ptr = ::_pbi::ReadTag(ptr, &tag);
1589 switch (tag >> 3) {
1590 // optional int32 adapter_nr = 1;
1591 case 1:
1592 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1593 _Internal::set_has_adapter_nr(&has_bits);
1594 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1595 CHK_(ptr);
1596 } else {
1597 goto handle_unusual;
1598 }
1599 continue;
1600 // optional uint32 flags = 2;
1601 case 2:
1602 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1603 _Internal::set_has_flags(&has_bits);
1604 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1605 CHK_(ptr);
1606 } else {
1607 goto handle_unusual;
1608 }
1609 continue;
1610 // optional uint32 addr = 3;
1611 case 3:
1612 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1613 _Internal::set_has_addr(&has_bits);
1614 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1615 CHK_(ptr);
1616 } else {
1617 goto handle_unusual;
1618 }
1619 continue;
1620 // optional uint32 command = 4;
1621 case 4:
1622 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1623 _Internal::set_has_command(&has_bits);
1624 _impl_.command_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1625 CHK_(ptr);
1626 } else {
1627 goto handle_unusual;
1628 }
1629 continue;
1630 // optional uint32 protocol = 5;
1631 case 5:
1632 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1633 _Internal::set_has_protocol(&has_bits);
1634 _impl_.protocol_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1635 CHK_(ptr);
1636 } else {
1637 goto handle_unusual;
1638 }
1639 continue;
1640 default:
1641 goto handle_unusual;
1642 } // switch
1643 handle_unusual:
1644 if ((tag == 0) || ((tag & 7) == 4)) {
1645 CHK_(ptr);
1646 ctx->SetLastTag(tag);
1647 goto message_done;
1648 }
1649 ptr = UnknownFieldParse(
1650 tag,
1651 _internal_metadata_.mutable_unknown_fields<std::string>(),
1652 ptr, ctx);
1653 CHK_(ptr != nullptr);
1654 } // while
1655 message_done:
1656 _impl_._has_bits_.Or(has_bits);
1657 return ptr;
1658 failure:
1659 ptr = nullptr;
1660 goto message_done;
1661 #undef CHK_
1662 }
1663
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1664 ::uint8_t* SmbusReadFtraceEvent::_InternalSerialize(
1665 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1666 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SmbusReadFtraceEvent)
1667 ::uint32_t cached_has_bits = 0;
1668 (void) cached_has_bits;
1669
1670 cached_has_bits = _impl_._has_bits_[0];
1671 // optional int32 adapter_nr = 1;
1672 if (cached_has_bits & 0x00000001u) {
1673 target = stream->EnsureSpace(target);
1674 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
1675 }
1676
1677 // optional uint32 flags = 2;
1678 if (cached_has_bits & 0x00000002u) {
1679 target = stream->EnsureSpace(target);
1680 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_flags(), target);
1681 }
1682
1683 // optional uint32 addr = 3;
1684 if (cached_has_bits & 0x00000004u) {
1685 target = stream->EnsureSpace(target);
1686 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_addr(), target);
1687 }
1688
1689 // optional uint32 command = 4;
1690 if (cached_has_bits & 0x00000008u) {
1691 target = stream->EnsureSpace(target);
1692 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_command(), target);
1693 }
1694
1695 // optional uint32 protocol = 5;
1696 if (cached_has_bits & 0x00000010u) {
1697 target = stream->EnsureSpace(target);
1698 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_protocol(), target);
1699 }
1700
1701 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1702 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1703 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1704 }
1705 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SmbusReadFtraceEvent)
1706 return target;
1707 }
1708
ByteSizeLong() const1709 size_t SmbusReadFtraceEvent::ByteSizeLong() const {
1710 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SmbusReadFtraceEvent)
1711 size_t total_size = 0;
1712
1713 ::uint32_t cached_has_bits = 0;
1714 // Prevent compiler warnings about cached_has_bits being unused
1715 (void) cached_has_bits;
1716
1717 cached_has_bits = _impl_._has_bits_[0];
1718 if (cached_has_bits & 0x0000001fu) {
1719 // optional int32 adapter_nr = 1;
1720 if (cached_has_bits & 0x00000001u) {
1721 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
1722 }
1723
1724 // optional uint32 flags = 2;
1725 if (cached_has_bits & 0x00000002u) {
1726 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
1727 }
1728
1729 // optional uint32 addr = 3;
1730 if (cached_has_bits & 0x00000004u) {
1731 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
1732 }
1733
1734 // optional uint32 command = 4;
1735 if (cached_has_bits & 0x00000008u) {
1736 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_command());
1737 }
1738
1739 // optional uint32 protocol = 5;
1740 if (cached_has_bits & 0x00000010u) {
1741 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol());
1742 }
1743
1744 }
1745 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1746 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1747 }
1748 int cached_size = ::_pbi::ToCachedSize(total_size);
1749 SetCachedSize(cached_size);
1750 return total_size;
1751 }
1752
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1753 void SmbusReadFtraceEvent::CheckTypeAndMergeFrom(
1754 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1755 MergeFrom(*::_pbi::DownCast<const SmbusReadFtraceEvent*>(
1756 &from));
1757 }
1758
MergeFrom(const SmbusReadFtraceEvent & from)1759 void SmbusReadFtraceEvent::MergeFrom(const SmbusReadFtraceEvent& from) {
1760 SmbusReadFtraceEvent* const _this = this;
1761 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SmbusReadFtraceEvent)
1762 GOOGLE_DCHECK_NE(&from, _this);
1763 ::uint32_t cached_has_bits = 0;
1764 (void) cached_has_bits;
1765
1766 cached_has_bits = from._impl_._has_bits_[0];
1767 if (cached_has_bits & 0x0000001fu) {
1768 if (cached_has_bits & 0x00000001u) {
1769 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
1770 }
1771 if (cached_has_bits & 0x00000002u) {
1772 _this->_impl_.flags_ = from._impl_.flags_;
1773 }
1774 if (cached_has_bits & 0x00000004u) {
1775 _this->_impl_.addr_ = from._impl_.addr_;
1776 }
1777 if (cached_has_bits & 0x00000008u) {
1778 _this->_impl_.command_ = from._impl_.command_;
1779 }
1780 if (cached_has_bits & 0x00000010u) {
1781 _this->_impl_.protocol_ = from._impl_.protocol_;
1782 }
1783 _this->_impl_._has_bits_[0] |= cached_has_bits;
1784 }
1785 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1786 }
1787
CopyFrom(const SmbusReadFtraceEvent & from)1788 void SmbusReadFtraceEvent::CopyFrom(const SmbusReadFtraceEvent& from) {
1789 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SmbusReadFtraceEvent)
1790 if (&from == this) return;
1791 Clear();
1792 MergeFrom(from);
1793 }
1794
IsInitialized() const1795 bool SmbusReadFtraceEvent::IsInitialized() const {
1796 return true;
1797 }
1798
InternalSwap(SmbusReadFtraceEvent * other)1799 void SmbusReadFtraceEvent::InternalSwap(SmbusReadFtraceEvent* other) {
1800 using std::swap;
1801 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1802 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1803 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1804 PROTOBUF_FIELD_OFFSET(SmbusReadFtraceEvent, _impl_.protocol_)
1805 + sizeof(SmbusReadFtraceEvent::_impl_.protocol_) // NOLINT
1806 - PROTOBUF_FIELD_OFFSET(SmbusReadFtraceEvent, _impl_.adapter_nr_)>(
1807 reinterpret_cast<char*>(&_impl_.adapter_nr_),
1808 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
1809 }
1810
GetTypeName() const1811 std::string SmbusReadFtraceEvent::GetTypeName() const {
1812 return "perfetto.protos.SmbusReadFtraceEvent";
1813 }
1814
1815
1816 // ===================================================================
1817
1818 class SmbusWriteFtraceEvent::_Internal {
1819 public:
1820 using HasBits = decltype(std::declval<SmbusWriteFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)1821 static void set_has_adapter_nr(HasBits* has_bits) {
1822 (*has_bits)[0] |= 1u;
1823 }
set_has_addr(HasBits * has_bits)1824 static void set_has_addr(HasBits* has_bits) {
1825 (*has_bits)[0] |= 2u;
1826 }
set_has_flags(HasBits * has_bits)1827 static void set_has_flags(HasBits* has_bits) {
1828 (*has_bits)[0] |= 4u;
1829 }
set_has_command(HasBits * has_bits)1830 static void set_has_command(HasBits* has_bits) {
1831 (*has_bits)[0] |= 8u;
1832 }
set_has_len(HasBits * has_bits)1833 static void set_has_len(HasBits* has_bits) {
1834 (*has_bits)[0] |= 16u;
1835 }
set_has_protocol(HasBits * has_bits)1836 static void set_has_protocol(HasBits* has_bits) {
1837 (*has_bits)[0] |= 32u;
1838 }
1839 };
1840
SmbusWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1841 SmbusWriteFtraceEvent::SmbusWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1842 bool is_message_owned)
1843 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1844 SharedCtor(arena, is_message_owned);
1845 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SmbusWriteFtraceEvent)
1846 }
SmbusWriteFtraceEvent(const SmbusWriteFtraceEvent & from)1847 SmbusWriteFtraceEvent::SmbusWriteFtraceEvent(const SmbusWriteFtraceEvent& from)
1848 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1849 SmbusWriteFtraceEvent* const _this = this; (void)_this;
1850 new (&_impl_) Impl_{
1851 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1852 , /*decltype(_impl_._cached_size_)*/{}
1853 , decltype(_impl_.adapter_nr_){}
1854 , decltype(_impl_.addr_){}
1855 , decltype(_impl_.flags_){}
1856 , decltype(_impl_.command_){}
1857 , decltype(_impl_.len_){}
1858 , decltype(_impl_.protocol_){}};
1859
1860 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1861 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
1862 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.protocol_) -
1863 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
1864 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SmbusWriteFtraceEvent)
1865 }
1866
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1867 inline void SmbusWriteFtraceEvent::SharedCtor(
1868 ::_pb::Arena* arena, bool is_message_owned) {
1869 (void)arena;
1870 (void)is_message_owned;
1871 new (&_impl_) Impl_{
1872 decltype(_impl_._has_bits_){}
1873 , /*decltype(_impl_._cached_size_)*/{}
1874 , decltype(_impl_.adapter_nr_){0}
1875 , decltype(_impl_.addr_){0u}
1876 , decltype(_impl_.flags_){0u}
1877 , decltype(_impl_.command_){0u}
1878 , decltype(_impl_.len_){0u}
1879 , decltype(_impl_.protocol_){0u}
1880 };
1881 }
1882
~SmbusWriteFtraceEvent()1883 SmbusWriteFtraceEvent::~SmbusWriteFtraceEvent() {
1884 // @@protoc_insertion_point(destructor:perfetto.protos.SmbusWriteFtraceEvent)
1885 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1886 (void)arena;
1887 return;
1888 }
1889 SharedDtor();
1890 }
1891
SharedDtor()1892 inline void SmbusWriteFtraceEvent::SharedDtor() {
1893 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1894 }
1895
SetCachedSize(int size) const1896 void SmbusWriteFtraceEvent::SetCachedSize(int size) const {
1897 _impl_._cached_size_.Set(size);
1898 }
1899
Clear()1900 void SmbusWriteFtraceEvent::Clear() {
1901 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SmbusWriteFtraceEvent)
1902 ::uint32_t cached_has_bits = 0;
1903 // Prevent compiler warnings about cached_has_bits being unused
1904 (void) cached_has_bits;
1905
1906 cached_has_bits = _impl_._has_bits_[0];
1907 if (cached_has_bits & 0x0000003fu) {
1908 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
1909 reinterpret_cast<char*>(&_impl_.protocol_) -
1910 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
1911 }
1912 _impl_._has_bits_.Clear();
1913 _internal_metadata_.Clear<std::string>();
1914 }
1915
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1916 const char* SmbusWriteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1917 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1918 _Internal::HasBits has_bits{};
1919 while (!ctx->Done(&ptr)) {
1920 ::uint32_t tag;
1921 ptr = ::_pbi::ReadTag(ptr, &tag);
1922 switch (tag >> 3) {
1923 // optional int32 adapter_nr = 1;
1924 case 1:
1925 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1926 _Internal::set_has_adapter_nr(&has_bits);
1927 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1928 CHK_(ptr);
1929 } else {
1930 goto handle_unusual;
1931 }
1932 continue;
1933 // optional uint32 addr = 2;
1934 case 2:
1935 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1936 _Internal::set_has_addr(&has_bits);
1937 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1938 CHK_(ptr);
1939 } else {
1940 goto handle_unusual;
1941 }
1942 continue;
1943 // optional uint32 flags = 3;
1944 case 3:
1945 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1946 _Internal::set_has_flags(&has_bits);
1947 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1948 CHK_(ptr);
1949 } else {
1950 goto handle_unusual;
1951 }
1952 continue;
1953 // optional uint32 command = 4;
1954 case 4:
1955 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1956 _Internal::set_has_command(&has_bits);
1957 _impl_.command_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1958 CHK_(ptr);
1959 } else {
1960 goto handle_unusual;
1961 }
1962 continue;
1963 // optional uint32 len = 5;
1964 case 5:
1965 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1966 _Internal::set_has_len(&has_bits);
1967 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1968 CHK_(ptr);
1969 } else {
1970 goto handle_unusual;
1971 }
1972 continue;
1973 // optional uint32 protocol = 6;
1974 case 6:
1975 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1976 _Internal::set_has_protocol(&has_bits);
1977 _impl_.protocol_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1978 CHK_(ptr);
1979 } else {
1980 goto handle_unusual;
1981 }
1982 continue;
1983 default:
1984 goto handle_unusual;
1985 } // switch
1986 handle_unusual:
1987 if ((tag == 0) || ((tag & 7) == 4)) {
1988 CHK_(ptr);
1989 ctx->SetLastTag(tag);
1990 goto message_done;
1991 }
1992 ptr = UnknownFieldParse(
1993 tag,
1994 _internal_metadata_.mutable_unknown_fields<std::string>(),
1995 ptr, ctx);
1996 CHK_(ptr != nullptr);
1997 } // while
1998 message_done:
1999 _impl_._has_bits_.Or(has_bits);
2000 return ptr;
2001 failure:
2002 ptr = nullptr;
2003 goto message_done;
2004 #undef CHK_
2005 }
2006
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2007 ::uint8_t* SmbusWriteFtraceEvent::_InternalSerialize(
2008 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2009 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SmbusWriteFtraceEvent)
2010 ::uint32_t cached_has_bits = 0;
2011 (void) cached_has_bits;
2012
2013 cached_has_bits = _impl_._has_bits_[0];
2014 // optional int32 adapter_nr = 1;
2015 if (cached_has_bits & 0x00000001u) {
2016 target = stream->EnsureSpace(target);
2017 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
2018 }
2019
2020 // optional uint32 addr = 2;
2021 if (cached_has_bits & 0x00000002u) {
2022 target = stream->EnsureSpace(target);
2023 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_addr(), target);
2024 }
2025
2026 // optional uint32 flags = 3;
2027 if (cached_has_bits & 0x00000004u) {
2028 target = stream->EnsureSpace(target);
2029 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_flags(), target);
2030 }
2031
2032 // optional uint32 command = 4;
2033 if (cached_has_bits & 0x00000008u) {
2034 target = stream->EnsureSpace(target);
2035 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_command(), target);
2036 }
2037
2038 // optional uint32 len = 5;
2039 if (cached_has_bits & 0x00000010u) {
2040 target = stream->EnsureSpace(target);
2041 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_len(), target);
2042 }
2043
2044 // optional uint32 protocol = 6;
2045 if (cached_has_bits & 0x00000020u) {
2046 target = stream->EnsureSpace(target);
2047 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_protocol(), target);
2048 }
2049
2050 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2051 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2052 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2053 }
2054 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SmbusWriteFtraceEvent)
2055 return target;
2056 }
2057
ByteSizeLong() const2058 size_t SmbusWriteFtraceEvent::ByteSizeLong() const {
2059 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SmbusWriteFtraceEvent)
2060 size_t total_size = 0;
2061
2062 ::uint32_t cached_has_bits = 0;
2063 // Prevent compiler warnings about cached_has_bits being unused
2064 (void) cached_has_bits;
2065
2066 cached_has_bits = _impl_._has_bits_[0];
2067 if (cached_has_bits & 0x0000003fu) {
2068 // optional int32 adapter_nr = 1;
2069 if (cached_has_bits & 0x00000001u) {
2070 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
2071 }
2072
2073 // optional uint32 addr = 2;
2074 if (cached_has_bits & 0x00000002u) {
2075 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
2076 }
2077
2078 // optional uint32 flags = 3;
2079 if (cached_has_bits & 0x00000004u) {
2080 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
2081 }
2082
2083 // optional uint32 command = 4;
2084 if (cached_has_bits & 0x00000008u) {
2085 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_command());
2086 }
2087
2088 // optional uint32 len = 5;
2089 if (cached_has_bits & 0x00000010u) {
2090 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
2091 }
2092
2093 // optional uint32 protocol = 6;
2094 if (cached_has_bits & 0x00000020u) {
2095 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol());
2096 }
2097
2098 }
2099 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2100 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2101 }
2102 int cached_size = ::_pbi::ToCachedSize(total_size);
2103 SetCachedSize(cached_size);
2104 return total_size;
2105 }
2106
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2107 void SmbusWriteFtraceEvent::CheckTypeAndMergeFrom(
2108 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2109 MergeFrom(*::_pbi::DownCast<const SmbusWriteFtraceEvent*>(
2110 &from));
2111 }
2112
MergeFrom(const SmbusWriteFtraceEvent & from)2113 void SmbusWriteFtraceEvent::MergeFrom(const SmbusWriteFtraceEvent& from) {
2114 SmbusWriteFtraceEvent* const _this = this;
2115 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SmbusWriteFtraceEvent)
2116 GOOGLE_DCHECK_NE(&from, _this);
2117 ::uint32_t cached_has_bits = 0;
2118 (void) cached_has_bits;
2119
2120 cached_has_bits = from._impl_._has_bits_[0];
2121 if (cached_has_bits & 0x0000003fu) {
2122 if (cached_has_bits & 0x00000001u) {
2123 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
2124 }
2125 if (cached_has_bits & 0x00000002u) {
2126 _this->_impl_.addr_ = from._impl_.addr_;
2127 }
2128 if (cached_has_bits & 0x00000004u) {
2129 _this->_impl_.flags_ = from._impl_.flags_;
2130 }
2131 if (cached_has_bits & 0x00000008u) {
2132 _this->_impl_.command_ = from._impl_.command_;
2133 }
2134 if (cached_has_bits & 0x00000010u) {
2135 _this->_impl_.len_ = from._impl_.len_;
2136 }
2137 if (cached_has_bits & 0x00000020u) {
2138 _this->_impl_.protocol_ = from._impl_.protocol_;
2139 }
2140 _this->_impl_._has_bits_[0] |= cached_has_bits;
2141 }
2142 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2143 }
2144
CopyFrom(const SmbusWriteFtraceEvent & from)2145 void SmbusWriteFtraceEvent::CopyFrom(const SmbusWriteFtraceEvent& from) {
2146 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SmbusWriteFtraceEvent)
2147 if (&from == this) return;
2148 Clear();
2149 MergeFrom(from);
2150 }
2151
IsInitialized() const2152 bool SmbusWriteFtraceEvent::IsInitialized() const {
2153 return true;
2154 }
2155
InternalSwap(SmbusWriteFtraceEvent * other)2156 void SmbusWriteFtraceEvent::InternalSwap(SmbusWriteFtraceEvent* other) {
2157 using std::swap;
2158 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2159 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2160 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2161 PROTOBUF_FIELD_OFFSET(SmbusWriteFtraceEvent, _impl_.protocol_)
2162 + sizeof(SmbusWriteFtraceEvent::_impl_.protocol_) // NOLINT
2163 - PROTOBUF_FIELD_OFFSET(SmbusWriteFtraceEvent, _impl_.adapter_nr_)>(
2164 reinterpret_cast<char*>(&_impl_.adapter_nr_),
2165 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
2166 }
2167
GetTypeName() const2168 std::string SmbusWriteFtraceEvent::GetTypeName() const {
2169 return "perfetto.protos.SmbusWriteFtraceEvent";
2170 }
2171
2172
2173 // ===================================================================
2174
2175 class SmbusResultFtraceEvent::_Internal {
2176 public:
2177 using HasBits = decltype(std::declval<SmbusResultFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)2178 static void set_has_adapter_nr(HasBits* has_bits) {
2179 (*has_bits)[0] |= 1u;
2180 }
set_has_addr(HasBits * has_bits)2181 static void set_has_addr(HasBits* has_bits) {
2182 (*has_bits)[0] |= 2u;
2183 }
set_has_flags(HasBits * has_bits)2184 static void set_has_flags(HasBits* has_bits) {
2185 (*has_bits)[0] |= 4u;
2186 }
set_has_read_write(HasBits * has_bits)2187 static void set_has_read_write(HasBits* has_bits) {
2188 (*has_bits)[0] |= 8u;
2189 }
set_has_command(HasBits * has_bits)2190 static void set_has_command(HasBits* has_bits) {
2191 (*has_bits)[0] |= 16u;
2192 }
set_has_res(HasBits * has_bits)2193 static void set_has_res(HasBits* has_bits) {
2194 (*has_bits)[0] |= 32u;
2195 }
set_has_protocol(HasBits * has_bits)2196 static void set_has_protocol(HasBits* has_bits) {
2197 (*has_bits)[0] |= 64u;
2198 }
2199 };
2200
SmbusResultFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2201 SmbusResultFtraceEvent::SmbusResultFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2202 bool is_message_owned)
2203 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2204 SharedCtor(arena, is_message_owned);
2205 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SmbusResultFtraceEvent)
2206 }
SmbusResultFtraceEvent(const SmbusResultFtraceEvent & from)2207 SmbusResultFtraceEvent::SmbusResultFtraceEvent(const SmbusResultFtraceEvent& from)
2208 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2209 SmbusResultFtraceEvent* const _this = this; (void)_this;
2210 new (&_impl_) Impl_{
2211 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2212 , /*decltype(_impl_._cached_size_)*/{}
2213 , decltype(_impl_.adapter_nr_){}
2214 , decltype(_impl_.addr_){}
2215 , decltype(_impl_.flags_){}
2216 , decltype(_impl_.read_write_){}
2217 , decltype(_impl_.command_){}
2218 , decltype(_impl_.res_){}
2219 , decltype(_impl_.protocol_){}};
2220
2221 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2222 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
2223 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.protocol_) -
2224 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
2225 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SmbusResultFtraceEvent)
2226 }
2227
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2228 inline void SmbusResultFtraceEvent::SharedCtor(
2229 ::_pb::Arena* arena, bool is_message_owned) {
2230 (void)arena;
2231 (void)is_message_owned;
2232 new (&_impl_) Impl_{
2233 decltype(_impl_._has_bits_){}
2234 , /*decltype(_impl_._cached_size_)*/{}
2235 , decltype(_impl_.adapter_nr_){0}
2236 , decltype(_impl_.addr_){0u}
2237 , decltype(_impl_.flags_){0u}
2238 , decltype(_impl_.read_write_){0u}
2239 , decltype(_impl_.command_){0u}
2240 , decltype(_impl_.res_){0}
2241 , decltype(_impl_.protocol_){0u}
2242 };
2243 }
2244
~SmbusResultFtraceEvent()2245 SmbusResultFtraceEvent::~SmbusResultFtraceEvent() {
2246 // @@protoc_insertion_point(destructor:perfetto.protos.SmbusResultFtraceEvent)
2247 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2248 (void)arena;
2249 return;
2250 }
2251 SharedDtor();
2252 }
2253
SharedDtor()2254 inline void SmbusResultFtraceEvent::SharedDtor() {
2255 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2256 }
2257
SetCachedSize(int size) const2258 void SmbusResultFtraceEvent::SetCachedSize(int size) const {
2259 _impl_._cached_size_.Set(size);
2260 }
2261
Clear()2262 void SmbusResultFtraceEvent::Clear() {
2263 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SmbusResultFtraceEvent)
2264 ::uint32_t cached_has_bits = 0;
2265 // Prevent compiler warnings about cached_has_bits being unused
2266 (void) cached_has_bits;
2267
2268 cached_has_bits = _impl_._has_bits_[0];
2269 if (cached_has_bits & 0x0000007fu) {
2270 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
2271 reinterpret_cast<char*>(&_impl_.protocol_) -
2272 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
2273 }
2274 _impl_._has_bits_.Clear();
2275 _internal_metadata_.Clear<std::string>();
2276 }
2277
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2278 const char* SmbusResultFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2279 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2280 _Internal::HasBits has_bits{};
2281 while (!ctx->Done(&ptr)) {
2282 ::uint32_t tag;
2283 ptr = ::_pbi::ReadTag(ptr, &tag);
2284 switch (tag >> 3) {
2285 // optional int32 adapter_nr = 1;
2286 case 1:
2287 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2288 _Internal::set_has_adapter_nr(&has_bits);
2289 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2290 CHK_(ptr);
2291 } else {
2292 goto handle_unusual;
2293 }
2294 continue;
2295 // optional uint32 addr = 2;
2296 case 2:
2297 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2298 _Internal::set_has_addr(&has_bits);
2299 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2300 CHK_(ptr);
2301 } else {
2302 goto handle_unusual;
2303 }
2304 continue;
2305 // optional uint32 flags = 3;
2306 case 3:
2307 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2308 _Internal::set_has_flags(&has_bits);
2309 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2310 CHK_(ptr);
2311 } else {
2312 goto handle_unusual;
2313 }
2314 continue;
2315 // optional uint32 read_write = 4;
2316 case 4:
2317 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2318 _Internal::set_has_read_write(&has_bits);
2319 _impl_.read_write_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2320 CHK_(ptr);
2321 } else {
2322 goto handle_unusual;
2323 }
2324 continue;
2325 // optional uint32 command = 5;
2326 case 5:
2327 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2328 _Internal::set_has_command(&has_bits);
2329 _impl_.command_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2330 CHK_(ptr);
2331 } else {
2332 goto handle_unusual;
2333 }
2334 continue;
2335 // optional int32 res = 6;
2336 case 6:
2337 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
2338 _Internal::set_has_res(&has_bits);
2339 _impl_.res_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2340 CHK_(ptr);
2341 } else {
2342 goto handle_unusual;
2343 }
2344 continue;
2345 // optional uint32 protocol = 7;
2346 case 7:
2347 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
2348 _Internal::set_has_protocol(&has_bits);
2349 _impl_.protocol_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2350 CHK_(ptr);
2351 } else {
2352 goto handle_unusual;
2353 }
2354 continue;
2355 default:
2356 goto handle_unusual;
2357 } // switch
2358 handle_unusual:
2359 if ((tag == 0) || ((tag & 7) == 4)) {
2360 CHK_(ptr);
2361 ctx->SetLastTag(tag);
2362 goto message_done;
2363 }
2364 ptr = UnknownFieldParse(
2365 tag,
2366 _internal_metadata_.mutable_unknown_fields<std::string>(),
2367 ptr, ctx);
2368 CHK_(ptr != nullptr);
2369 } // while
2370 message_done:
2371 _impl_._has_bits_.Or(has_bits);
2372 return ptr;
2373 failure:
2374 ptr = nullptr;
2375 goto message_done;
2376 #undef CHK_
2377 }
2378
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2379 ::uint8_t* SmbusResultFtraceEvent::_InternalSerialize(
2380 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2381 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SmbusResultFtraceEvent)
2382 ::uint32_t cached_has_bits = 0;
2383 (void) cached_has_bits;
2384
2385 cached_has_bits = _impl_._has_bits_[0];
2386 // optional int32 adapter_nr = 1;
2387 if (cached_has_bits & 0x00000001u) {
2388 target = stream->EnsureSpace(target);
2389 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
2390 }
2391
2392 // optional uint32 addr = 2;
2393 if (cached_has_bits & 0x00000002u) {
2394 target = stream->EnsureSpace(target);
2395 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_addr(), target);
2396 }
2397
2398 // optional uint32 flags = 3;
2399 if (cached_has_bits & 0x00000004u) {
2400 target = stream->EnsureSpace(target);
2401 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_flags(), target);
2402 }
2403
2404 // optional uint32 read_write = 4;
2405 if (cached_has_bits & 0x00000008u) {
2406 target = stream->EnsureSpace(target);
2407 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_read_write(), target);
2408 }
2409
2410 // optional uint32 command = 5;
2411 if (cached_has_bits & 0x00000010u) {
2412 target = stream->EnsureSpace(target);
2413 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_command(), target);
2414 }
2415
2416 // optional int32 res = 6;
2417 if (cached_has_bits & 0x00000020u) {
2418 target = stream->EnsureSpace(target);
2419 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_res(), target);
2420 }
2421
2422 // optional uint32 protocol = 7;
2423 if (cached_has_bits & 0x00000040u) {
2424 target = stream->EnsureSpace(target);
2425 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_protocol(), target);
2426 }
2427
2428 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2429 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2430 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2431 }
2432 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SmbusResultFtraceEvent)
2433 return target;
2434 }
2435
ByteSizeLong() const2436 size_t SmbusResultFtraceEvent::ByteSizeLong() const {
2437 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SmbusResultFtraceEvent)
2438 size_t total_size = 0;
2439
2440 ::uint32_t cached_has_bits = 0;
2441 // Prevent compiler warnings about cached_has_bits being unused
2442 (void) cached_has_bits;
2443
2444 cached_has_bits = _impl_._has_bits_[0];
2445 if (cached_has_bits & 0x0000007fu) {
2446 // optional int32 adapter_nr = 1;
2447 if (cached_has_bits & 0x00000001u) {
2448 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
2449 }
2450
2451 // optional uint32 addr = 2;
2452 if (cached_has_bits & 0x00000002u) {
2453 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
2454 }
2455
2456 // optional uint32 flags = 3;
2457 if (cached_has_bits & 0x00000004u) {
2458 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
2459 }
2460
2461 // optional uint32 read_write = 4;
2462 if (cached_has_bits & 0x00000008u) {
2463 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_read_write());
2464 }
2465
2466 // optional uint32 command = 5;
2467 if (cached_has_bits & 0x00000010u) {
2468 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_command());
2469 }
2470
2471 // optional int32 res = 6;
2472 if (cached_has_bits & 0x00000020u) {
2473 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_res());
2474 }
2475
2476 // optional uint32 protocol = 7;
2477 if (cached_has_bits & 0x00000040u) {
2478 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol());
2479 }
2480
2481 }
2482 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2483 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2484 }
2485 int cached_size = ::_pbi::ToCachedSize(total_size);
2486 SetCachedSize(cached_size);
2487 return total_size;
2488 }
2489
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2490 void SmbusResultFtraceEvent::CheckTypeAndMergeFrom(
2491 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2492 MergeFrom(*::_pbi::DownCast<const SmbusResultFtraceEvent*>(
2493 &from));
2494 }
2495
MergeFrom(const SmbusResultFtraceEvent & from)2496 void SmbusResultFtraceEvent::MergeFrom(const SmbusResultFtraceEvent& from) {
2497 SmbusResultFtraceEvent* const _this = this;
2498 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SmbusResultFtraceEvent)
2499 GOOGLE_DCHECK_NE(&from, _this);
2500 ::uint32_t cached_has_bits = 0;
2501 (void) cached_has_bits;
2502
2503 cached_has_bits = from._impl_._has_bits_[0];
2504 if (cached_has_bits & 0x0000007fu) {
2505 if (cached_has_bits & 0x00000001u) {
2506 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
2507 }
2508 if (cached_has_bits & 0x00000002u) {
2509 _this->_impl_.addr_ = from._impl_.addr_;
2510 }
2511 if (cached_has_bits & 0x00000004u) {
2512 _this->_impl_.flags_ = from._impl_.flags_;
2513 }
2514 if (cached_has_bits & 0x00000008u) {
2515 _this->_impl_.read_write_ = from._impl_.read_write_;
2516 }
2517 if (cached_has_bits & 0x00000010u) {
2518 _this->_impl_.command_ = from._impl_.command_;
2519 }
2520 if (cached_has_bits & 0x00000020u) {
2521 _this->_impl_.res_ = from._impl_.res_;
2522 }
2523 if (cached_has_bits & 0x00000040u) {
2524 _this->_impl_.protocol_ = from._impl_.protocol_;
2525 }
2526 _this->_impl_._has_bits_[0] |= cached_has_bits;
2527 }
2528 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2529 }
2530
CopyFrom(const SmbusResultFtraceEvent & from)2531 void SmbusResultFtraceEvent::CopyFrom(const SmbusResultFtraceEvent& from) {
2532 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SmbusResultFtraceEvent)
2533 if (&from == this) return;
2534 Clear();
2535 MergeFrom(from);
2536 }
2537
IsInitialized() const2538 bool SmbusResultFtraceEvent::IsInitialized() const {
2539 return true;
2540 }
2541
InternalSwap(SmbusResultFtraceEvent * other)2542 void SmbusResultFtraceEvent::InternalSwap(SmbusResultFtraceEvent* other) {
2543 using std::swap;
2544 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2545 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2546 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2547 PROTOBUF_FIELD_OFFSET(SmbusResultFtraceEvent, _impl_.protocol_)
2548 + sizeof(SmbusResultFtraceEvent::_impl_.protocol_) // NOLINT
2549 - PROTOBUF_FIELD_OFFSET(SmbusResultFtraceEvent, _impl_.adapter_nr_)>(
2550 reinterpret_cast<char*>(&_impl_.adapter_nr_),
2551 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
2552 }
2553
GetTypeName() const2554 std::string SmbusResultFtraceEvent::GetTypeName() const {
2555 return "perfetto.protos.SmbusResultFtraceEvent";
2556 }
2557
2558
2559 // ===================================================================
2560
2561 class SmbusReplyFtraceEvent::_Internal {
2562 public:
2563 using HasBits = decltype(std::declval<SmbusReplyFtraceEvent>()._impl_._has_bits_);
set_has_adapter_nr(HasBits * has_bits)2564 static void set_has_adapter_nr(HasBits* has_bits) {
2565 (*has_bits)[0] |= 1u;
2566 }
set_has_addr(HasBits * has_bits)2567 static void set_has_addr(HasBits* has_bits) {
2568 (*has_bits)[0] |= 2u;
2569 }
set_has_flags(HasBits * has_bits)2570 static void set_has_flags(HasBits* has_bits) {
2571 (*has_bits)[0] |= 4u;
2572 }
set_has_command(HasBits * has_bits)2573 static void set_has_command(HasBits* has_bits) {
2574 (*has_bits)[0] |= 8u;
2575 }
set_has_len(HasBits * has_bits)2576 static void set_has_len(HasBits* has_bits) {
2577 (*has_bits)[0] |= 16u;
2578 }
set_has_protocol(HasBits * has_bits)2579 static void set_has_protocol(HasBits* has_bits) {
2580 (*has_bits)[0] |= 32u;
2581 }
2582 };
2583
SmbusReplyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2584 SmbusReplyFtraceEvent::SmbusReplyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2585 bool is_message_owned)
2586 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2587 SharedCtor(arena, is_message_owned);
2588 // @@protoc_insertion_point(arena_constructor:perfetto.protos.SmbusReplyFtraceEvent)
2589 }
SmbusReplyFtraceEvent(const SmbusReplyFtraceEvent & from)2590 SmbusReplyFtraceEvent::SmbusReplyFtraceEvent(const SmbusReplyFtraceEvent& from)
2591 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2592 SmbusReplyFtraceEvent* const _this = this; (void)_this;
2593 new (&_impl_) Impl_{
2594 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2595 , /*decltype(_impl_._cached_size_)*/{}
2596 , decltype(_impl_.adapter_nr_){}
2597 , decltype(_impl_.addr_){}
2598 , decltype(_impl_.flags_){}
2599 , decltype(_impl_.command_){}
2600 , decltype(_impl_.len_){}
2601 , decltype(_impl_.protocol_){}};
2602
2603 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2604 ::memcpy(&_impl_.adapter_nr_, &from._impl_.adapter_nr_,
2605 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.protocol_) -
2606 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
2607 // @@protoc_insertion_point(copy_constructor:perfetto.protos.SmbusReplyFtraceEvent)
2608 }
2609
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2610 inline void SmbusReplyFtraceEvent::SharedCtor(
2611 ::_pb::Arena* arena, bool is_message_owned) {
2612 (void)arena;
2613 (void)is_message_owned;
2614 new (&_impl_) Impl_{
2615 decltype(_impl_._has_bits_){}
2616 , /*decltype(_impl_._cached_size_)*/{}
2617 , decltype(_impl_.adapter_nr_){0}
2618 , decltype(_impl_.addr_){0u}
2619 , decltype(_impl_.flags_){0u}
2620 , decltype(_impl_.command_){0u}
2621 , decltype(_impl_.len_){0u}
2622 , decltype(_impl_.protocol_){0u}
2623 };
2624 }
2625
~SmbusReplyFtraceEvent()2626 SmbusReplyFtraceEvent::~SmbusReplyFtraceEvent() {
2627 // @@protoc_insertion_point(destructor:perfetto.protos.SmbusReplyFtraceEvent)
2628 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2629 (void)arena;
2630 return;
2631 }
2632 SharedDtor();
2633 }
2634
SharedDtor()2635 inline void SmbusReplyFtraceEvent::SharedDtor() {
2636 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2637 }
2638
SetCachedSize(int size) const2639 void SmbusReplyFtraceEvent::SetCachedSize(int size) const {
2640 _impl_._cached_size_.Set(size);
2641 }
2642
Clear()2643 void SmbusReplyFtraceEvent::Clear() {
2644 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SmbusReplyFtraceEvent)
2645 ::uint32_t cached_has_bits = 0;
2646 // Prevent compiler warnings about cached_has_bits being unused
2647 (void) cached_has_bits;
2648
2649 cached_has_bits = _impl_._has_bits_[0];
2650 if (cached_has_bits & 0x0000003fu) {
2651 ::memset(&_impl_.adapter_nr_, 0, static_cast<size_t>(
2652 reinterpret_cast<char*>(&_impl_.protocol_) -
2653 reinterpret_cast<char*>(&_impl_.adapter_nr_)) + sizeof(_impl_.protocol_));
2654 }
2655 _impl_._has_bits_.Clear();
2656 _internal_metadata_.Clear<std::string>();
2657 }
2658
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2659 const char* SmbusReplyFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2660 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2661 _Internal::HasBits has_bits{};
2662 while (!ctx->Done(&ptr)) {
2663 ::uint32_t tag;
2664 ptr = ::_pbi::ReadTag(ptr, &tag);
2665 switch (tag >> 3) {
2666 // optional int32 adapter_nr = 1;
2667 case 1:
2668 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2669 _Internal::set_has_adapter_nr(&has_bits);
2670 _impl_.adapter_nr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2671 CHK_(ptr);
2672 } else {
2673 goto handle_unusual;
2674 }
2675 continue;
2676 // optional uint32 addr = 2;
2677 case 2:
2678 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2679 _Internal::set_has_addr(&has_bits);
2680 _impl_.addr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2681 CHK_(ptr);
2682 } else {
2683 goto handle_unusual;
2684 }
2685 continue;
2686 // optional uint32 flags = 3;
2687 case 3:
2688 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2689 _Internal::set_has_flags(&has_bits);
2690 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2691 CHK_(ptr);
2692 } else {
2693 goto handle_unusual;
2694 }
2695 continue;
2696 // optional uint32 command = 4;
2697 case 4:
2698 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2699 _Internal::set_has_command(&has_bits);
2700 _impl_.command_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2701 CHK_(ptr);
2702 } else {
2703 goto handle_unusual;
2704 }
2705 continue;
2706 // optional uint32 len = 5;
2707 case 5:
2708 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2709 _Internal::set_has_len(&has_bits);
2710 _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2711 CHK_(ptr);
2712 } else {
2713 goto handle_unusual;
2714 }
2715 continue;
2716 // optional uint32 protocol = 6;
2717 case 6:
2718 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
2719 _Internal::set_has_protocol(&has_bits);
2720 _impl_.protocol_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2721 CHK_(ptr);
2722 } else {
2723 goto handle_unusual;
2724 }
2725 continue;
2726 default:
2727 goto handle_unusual;
2728 } // switch
2729 handle_unusual:
2730 if ((tag == 0) || ((tag & 7) == 4)) {
2731 CHK_(ptr);
2732 ctx->SetLastTag(tag);
2733 goto message_done;
2734 }
2735 ptr = UnknownFieldParse(
2736 tag,
2737 _internal_metadata_.mutable_unknown_fields<std::string>(),
2738 ptr, ctx);
2739 CHK_(ptr != nullptr);
2740 } // while
2741 message_done:
2742 _impl_._has_bits_.Or(has_bits);
2743 return ptr;
2744 failure:
2745 ptr = nullptr;
2746 goto message_done;
2747 #undef CHK_
2748 }
2749
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2750 ::uint8_t* SmbusReplyFtraceEvent::_InternalSerialize(
2751 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2752 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SmbusReplyFtraceEvent)
2753 ::uint32_t cached_has_bits = 0;
2754 (void) cached_has_bits;
2755
2756 cached_has_bits = _impl_._has_bits_[0];
2757 // optional int32 adapter_nr = 1;
2758 if (cached_has_bits & 0x00000001u) {
2759 target = stream->EnsureSpace(target);
2760 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_adapter_nr(), target);
2761 }
2762
2763 // optional uint32 addr = 2;
2764 if (cached_has_bits & 0x00000002u) {
2765 target = stream->EnsureSpace(target);
2766 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_addr(), target);
2767 }
2768
2769 // optional uint32 flags = 3;
2770 if (cached_has_bits & 0x00000004u) {
2771 target = stream->EnsureSpace(target);
2772 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_flags(), target);
2773 }
2774
2775 // optional uint32 command = 4;
2776 if (cached_has_bits & 0x00000008u) {
2777 target = stream->EnsureSpace(target);
2778 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_command(), target);
2779 }
2780
2781 // optional uint32 len = 5;
2782 if (cached_has_bits & 0x00000010u) {
2783 target = stream->EnsureSpace(target);
2784 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_len(), target);
2785 }
2786
2787 // optional uint32 protocol = 6;
2788 if (cached_has_bits & 0x00000020u) {
2789 target = stream->EnsureSpace(target);
2790 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_protocol(), target);
2791 }
2792
2793 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2794 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2795 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2796 }
2797 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SmbusReplyFtraceEvent)
2798 return target;
2799 }
2800
ByteSizeLong() const2801 size_t SmbusReplyFtraceEvent::ByteSizeLong() const {
2802 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SmbusReplyFtraceEvent)
2803 size_t total_size = 0;
2804
2805 ::uint32_t cached_has_bits = 0;
2806 // Prevent compiler warnings about cached_has_bits being unused
2807 (void) cached_has_bits;
2808
2809 cached_has_bits = _impl_._has_bits_[0];
2810 if (cached_has_bits & 0x0000003fu) {
2811 // optional int32 adapter_nr = 1;
2812 if (cached_has_bits & 0x00000001u) {
2813 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_adapter_nr());
2814 }
2815
2816 // optional uint32 addr = 2;
2817 if (cached_has_bits & 0x00000002u) {
2818 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_addr());
2819 }
2820
2821 // optional uint32 flags = 3;
2822 if (cached_has_bits & 0x00000004u) {
2823 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
2824 }
2825
2826 // optional uint32 command = 4;
2827 if (cached_has_bits & 0x00000008u) {
2828 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_command());
2829 }
2830
2831 // optional uint32 len = 5;
2832 if (cached_has_bits & 0x00000010u) {
2833 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
2834 }
2835
2836 // optional uint32 protocol = 6;
2837 if (cached_has_bits & 0x00000020u) {
2838 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol());
2839 }
2840
2841 }
2842 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2843 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2844 }
2845 int cached_size = ::_pbi::ToCachedSize(total_size);
2846 SetCachedSize(cached_size);
2847 return total_size;
2848 }
2849
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2850 void SmbusReplyFtraceEvent::CheckTypeAndMergeFrom(
2851 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2852 MergeFrom(*::_pbi::DownCast<const SmbusReplyFtraceEvent*>(
2853 &from));
2854 }
2855
MergeFrom(const SmbusReplyFtraceEvent & from)2856 void SmbusReplyFtraceEvent::MergeFrom(const SmbusReplyFtraceEvent& from) {
2857 SmbusReplyFtraceEvent* const _this = this;
2858 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SmbusReplyFtraceEvent)
2859 GOOGLE_DCHECK_NE(&from, _this);
2860 ::uint32_t cached_has_bits = 0;
2861 (void) cached_has_bits;
2862
2863 cached_has_bits = from._impl_._has_bits_[0];
2864 if (cached_has_bits & 0x0000003fu) {
2865 if (cached_has_bits & 0x00000001u) {
2866 _this->_impl_.adapter_nr_ = from._impl_.adapter_nr_;
2867 }
2868 if (cached_has_bits & 0x00000002u) {
2869 _this->_impl_.addr_ = from._impl_.addr_;
2870 }
2871 if (cached_has_bits & 0x00000004u) {
2872 _this->_impl_.flags_ = from._impl_.flags_;
2873 }
2874 if (cached_has_bits & 0x00000008u) {
2875 _this->_impl_.command_ = from._impl_.command_;
2876 }
2877 if (cached_has_bits & 0x00000010u) {
2878 _this->_impl_.len_ = from._impl_.len_;
2879 }
2880 if (cached_has_bits & 0x00000020u) {
2881 _this->_impl_.protocol_ = from._impl_.protocol_;
2882 }
2883 _this->_impl_._has_bits_[0] |= cached_has_bits;
2884 }
2885 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2886 }
2887
CopyFrom(const SmbusReplyFtraceEvent & from)2888 void SmbusReplyFtraceEvent::CopyFrom(const SmbusReplyFtraceEvent& from) {
2889 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SmbusReplyFtraceEvent)
2890 if (&from == this) return;
2891 Clear();
2892 MergeFrom(from);
2893 }
2894
IsInitialized() const2895 bool SmbusReplyFtraceEvent::IsInitialized() const {
2896 return true;
2897 }
2898
InternalSwap(SmbusReplyFtraceEvent * other)2899 void SmbusReplyFtraceEvent::InternalSwap(SmbusReplyFtraceEvent* other) {
2900 using std::swap;
2901 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2902 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2903 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2904 PROTOBUF_FIELD_OFFSET(SmbusReplyFtraceEvent, _impl_.protocol_)
2905 + sizeof(SmbusReplyFtraceEvent::_impl_.protocol_) // NOLINT
2906 - PROTOBUF_FIELD_OFFSET(SmbusReplyFtraceEvent, _impl_.adapter_nr_)>(
2907 reinterpret_cast<char*>(&_impl_.adapter_nr_),
2908 reinterpret_cast<char*>(&other->_impl_.adapter_nr_));
2909 }
2910
GetTypeName() const2911 std::string SmbusReplyFtraceEvent::GetTypeName() const {
2912 return "perfetto.protos.SmbusReplyFtraceEvent";
2913 }
2914
2915
2916 // @@protoc_insertion_point(namespace_scope)
2917 } // namespace protos
2918 } // namespace perfetto
2919 PROTOBUF_NAMESPACE_OPEN
2920 template<> PROTOBUF_NOINLINE ::perfetto::protos::I2cReadFtraceEvent*
CreateMaybeMessage(Arena * arena)2921 Arena::CreateMaybeMessage< ::perfetto::protos::I2cReadFtraceEvent >(Arena* arena) {
2922 return Arena::CreateMessageInternal< ::perfetto::protos::I2cReadFtraceEvent >(arena);
2923 }
2924 template<> PROTOBUF_NOINLINE ::perfetto::protos::I2cWriteFtraceEvent*
CreateMaybeMessage(Arena * arena)2925 Arena::CreateMaybeMessage< ::perfetto::protos::I2cWriteFtraceEvent >(Arena* arena) {
2926 return Arena::CreateMessageInternal< ::perfetto::protos::I2cWriteFtraceEvent >(arena);
2927 }
2928 template<> PROTOBUF_NOINLINE ::perfetto::protos::I2cResultFtraceEvent*
CreateMaybeMessage(Arena * arena)2929 Arena::CreateMaybeMessage< ::perfetto::protos::I2cResultFtraceEvent >(Arena* arena) {
2930 return Arena::CreateMessageInternal< ::perfetto::protos::I2cResultFtraceEvent >(arena);
2931 }
2932 template<> PROTOBUF_NOINLINE ::perfetto::protos::I2cReplyFtraceEvent*
CreateMaybeMessage(Arena * arena)2933 Arena::CreateMaybeMessage< ::perfetto::protos::I2cReplyFtraceEvent >(Arena* arena) {
2934 return Arena::CreateMessageInternal< ::perfetto::protos::I2cReplyFtraceEvent >(arena);
2935 }
2936 template<> PROTOBUF_NOINLINE ::perfetto::protos::SmbusReadFtraceEvent*
CreateMaybeMessage(Arena * arena)2937 Arena::CreateMaybeMessage< ::perfetto::protos::SmbusReadFtraceEvent >(Arena* arena) {
2938 return Arena::CreateMessageInternal< ::perfetto::protos::SmbusReadFtraceEvent >(arena);
2939 }
2940 template<> PROTOBUF_NOINLINE ::perfetto::protos::SmbusWriteFtraceEvent*
CreateMaybeMessage(Arena * arena)2941 Arena::CreateMaybeMessage< ::perfetto::protos::SmbusWriteFtraceEvent >(Arena* arena) {
2942 return Arena::CreateMessageInternal< ::perfetto::protos::SmbusWriteFtraceEvent >(arena);
2943 }
2944 template<> PROTOBUF_NOINLINE ::perfetto::protos::SmbusResultFtraceEvent*
CreateMaybeMessage(Arena * arena)2945 Arena::CreateMaybeMessage< ::perfetto::protos::SmbusResultFtraceEvent >(Arena* arena) {
2946 return Arena::CreateMessageInternal< ::perfetto::protos::SmbusResultFtraceEvent >(arena);
2947 }
2948 template<> PROTOBUF_NOINLINE ::perfetto::protos::SmbusReplyFtraceEvent*
CreateMaybeMessage(Arena * arena)2949 Arena::CreateMaybeMessage< ::perfetto::protos::SmbusReplyFtraceEvent >(Arena* arena) {
2950 return Arena::CreateMessageInternal< ::perfetto::protos::SmbusReplyFtraceEvent >(arena);
2951 }
2952 PROTOBUF_NAMESPACE_CLOSE
2953
2954 // @@protoc_insertion_point(global_scope)
2955 #include <google/protobuf/port_undef.inc>
2956