1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/bcl_exynos.proto
3
4 #include "protos/perfetto/trace/ftrace/bcl_exynos.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 {
BclIrqTriggerFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR BclIrqTriggerFtraceEvent::BclIrqTriggerFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.id_)*/0
28 , /*decltype(_impl_.throttle_)*/0
29 , /*decltype(_impl_.cpu0_limit_)*/0
30 , /*decltype(_impl_.cpu1_limit_)*/0
31 , /*decltype(_impl_.cpu2_limit_)*/0
32 , /*decltype(_impl_.tpu_limit_)*/0
33 , /*decltype(_impl_.gpu_limit_)*/0
34 , /*decltype(_impl_.voltage_)*/0
35 , /*decltype(_impl_.capacity_)*/0} {}
36 struct BclIrqTriggerFtraceEventDefaultTypeInternal {
BclIrqTriggerFtraceEventDefaultTypeInternalperfetto::protos::BclIrqTriggerFtraceEventDefaultTypeInternal37 PROTOBUF_CONSTEXPR BclIrqTriggerFtraceEventDefaultTypeInternal()
38 : _instance(::_pbi::ConstantInitialized{}) {}
~BclIrqTriggerFtraceEventDefaultTypeInternalperfetto::protos::BclIrqTriggerFtraceEventDefaultTypeInternal39 ~BclIrqTriggerFtraceEventDefaultTypeInternal() {}
40 union { // NOLINT(misc-non-private-member-variables-in-classes)
41 BclIrqTriggerFtraceEvent _instance;
42 };
43 };
44 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BclIrqTriggerFtraceEventDefaultTypeInternal _BclIrqTriggerFtraceEvent_default_instance_;
45 } // namespace protos
46 } // namespace perfetto
47 namespace perfetto {
48 namespace protos {
49
50 // ===================================================================
51
52 class BclIrqTriggerFtraceEvent::_Internal {
53 public:
54 using HasBits = decltype(std::declval<BclIrqTriggerFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)55 static void set_has_id(HasBits* has_bits) {
56 (*has_bits)[0] |= 1u;
57 }
set_has_throttle(HasBits * has_bits)58 static void set_has_throttle(HasBits* has_bits) {
59 (*has_bits)[0] |= 2u;
60 }
set_has_cpu0_limit(HasBits * has_bits)61 static void set_has_cpu0_limit(HasBits* has_bits) {
62 (*has_bits)[0] |= 4u;
63 }
set_has_cpu1_limit(HasBits * has_bits)64 static void set_has_cpu1_limit(HasBits* has_bits) {
65 (*has_bits)[0] |= 8u;
66 }
set_has_cpu2_limit(HasBits * has_bits)67 static void set_has_cpu2_limit(HasBits* has_bits) {
68 (*has_bits)[0] |= 16u;
69 }
set_has_tpu_limit(HasBits * has_bits)70 static void set_has_tpu_limit(HasBits* has_bits) {
71 (*has_bits)[0] |= 32u;
72 }
set_has_gpu_limit(HasBits * has_bits)73 static void set_has_gpu_limit(HasBits* has_bits) {
74 (*has_bits)[0] |= 64u;
75 }
set_has_voltage(HasBits * has_bits)76 static void set_has_voltage(HasBits* has_bits) {
77 (*has_bits)[0] |= 128u;
78 }
set_has_capacity(HasBits * has_bits)79 static void set_has_capacity(HasBits* has_bits) {
80 (*has_bits)[0] |= 256u;
81 }
82 };
83
BclIrqTriggerFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)84 BclIrqTriggerFtraceEvent::BclIrqTriggerFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
85 bool is_message_owned)
86 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
87 SharedCtor(arena, is_message_owned);
88 // @@protoc_insertion_point(arena_constructor:perfetto.protos.BclIrqTriggerFtraceEvent)
89 }
BclIrqTriggerFtraceEvent(const BclIrqTriggerFtraceEvent & from)90 BclIrqTriggerFtraceEvent::BclIrqTriggerFtraceEvent(const BclIrqTriggerFtraceEvent& from)
91 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
92 BclIrqTriggerFtraceEvent* const _this = this; (void)_this;
93 new (&_impl_) Impl_{
94 decltype(_impl_._has_bits_){from._impl_._has_bits_}
95 , /*decltype(_impl_._cached_size_)*/{}
96 , decltype(_impl_.id_){}
97 , decltype(_impl_.throttle_){}
98 , decltype(_impl_.cpu0_limit_){}
99 , decltype(_impl_.cpu1_limit_){}
100 , decltype(_impl_.cpu2_limit_){}
101 , decltype(_impl_.tpu_limit_){}
102 , decltype(_impl_.gpu_limit_){}
103 , decltype(_impl_.voltage_){}
104 , decltype(_impl_.capacity_){}};
105
106 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
107 ::memcpy(&_impl_.id_, &from._impl_.id_,
108 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.capacity_) -
109 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.capacity_));
110 // @@protoc_insertion_point(copy_constructor:perfetto.protos.BclIrqTriggerFtraceEvent)
111 }
112
SharedCtor(::_pb::Arena * arena,bool is_message_owned)113 inline void BclIrqTriggerFtraceEvent::SharedCtor(
114 ::_pb::Arena* arena, bool is_message_owned) {
115 (void)arena;
116 (void)is_message_owned;
117 new (&_impl_) Impl_{
118 decltype(_impl_._has_bits_){}
119 , /*decltype(_impl_._cached_size_)*/{}
120 , decltype(_impl_.id_){0}
121 , decltype(_impl_.throttle_){0}
122 , decltype(_impl_.cpu0_limit_){0}
123 , decltype(_impl_.cpu1_limit_){0}
124 , decltype(_impl_.cpu2_limit_){0}
125 , decltype(_impl_.tpu_limit_){0}
126 , decltype(_impl_.gpu_limit_){0}
127 , decltype(_impl_.voltage_){0}
128 , decltype(_impl_.capacity_){0}
129 };
130 }
131
~BclIrqTriggerFtraceEvent()132 BclIrqTriggerFtraceEvent::~BclIrqTriggerFtraceEvent() {
133 // @@protoc_insertion_point(destructor:perfetto.protos.BclIrqTriggerFtraceEvent)
134 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
135 (void)arena;
136 return;
137 }
138 SharedDtor();
139 }
140
SharedDtor()141 inline void BclIrqTriggerFtraceEvent::SharedDtor() {
142 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
143 }
144
SetCachedSize(int size) const145 void BclIrqTriggerFtraceEvent::SetCachedSize(int size) const {
146 _impl_._cached_size_.Set(size);
147 }
148
Clear()149 void BclIrqTriggerFtraceEvent::Clear() {
150 // @@protoc_insertion_point(message_clear_start:perfetto.protos.BclIrqTriggerFtraceEvent)
151 ::uint32_t cached_has_bits = 0;
152 // Prevent compiler warnings about cached_has_bits being unused
153 (void) cached_has_bits;
154
155 cached_has_bits = _impl_._has_bits_[0];
156 if (cached_has_bits & 0x000000ffu) {
157 ::memset(&_impl_.id_, 0, static_cast<size_t>(
158 reinterpret_cast<char*>(&_impl_.voltage_) -
159 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.voltage_));
160 }
161 _impl_.capacity_ = 0;
162 _impl_._has_bits_.Clear();
163 _internal_metadata_.Clear<std::string>();
164 }
165
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)166 const char* BclIrqTriggerFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
167 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
168 _Internal::HasBits has_bits{};
169 while (!ctx->Done(&ptr)) {
170 ::uint32_t tag;
171 ptr = ::_pbi::ReadTag(ptr, &tag);
172 switch (tag >> 3) {
173 // optional int32 id = 1;
174 case 1:
175 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
176 _Internal::set_has_id(&has_bits);
177 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
178 CHK_(ptr);
179 } else {
180 goto handle_unusual;
181 }
182 continue;
183 // optional int32 throttle = 2;
184 case 2:
185 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
186 _Internal::set_has_throttle(&has_bits);
187 _impl_.throttle_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
188 CHK_(ptr);
189 } else {
190 goto handle_unusual;
191 }
192 continue;
193 // optional int32 cpu0_limit = 3;
194 case 3:
195 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
196 _Internal::set_has_cpu0_limit(&has_bits);
197 _impl_.cpu0_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
198 CHK_(ptr);
199 } else {
200 goto handle_unusual;
201 }
202 continue;
203 // optional int32 cpu1_limit = 4;
204 case 4:
205 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
206 _Internal::set_has_cpu1_limit(&has_bits);
207 _impl_.cpu1_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
208 CHK_(ptr);
209 } else {
210 goto handle_unusual;
211 }
212 continue;
213 // optional int32 cpu2_limit = 5;
214 case 5:
215 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
216 _Internal::set_has_cpu2_limit(&has_bits);
217 _impl_.cpu2_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
218 CHK_(ptr);
219 } else {
220 goto handle_unusual;
221 }
222 continue;
223 // optional int32 tpu_limit = 6;
224 case 6:
225 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
226 _Internal::set_has_tpu_limit(&has_bits);
227 _impl_.tpu_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
228 CHK_(ptr);
229 } else {
230 goto handle_unusual;
231 }
232 continue;
233 // optional int32 gpu_limit = 7;
234 case 7:
235 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
236 _Internal::set_has_gpu_limit(&has_bits);
237 _impl_.gpu_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
238 CHK_(ptr);
239 } else {
240 goto handle_unusual;
241 }
242 continue;
243 // optional int32 voltage = 8;
244 case 8:
245 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
246 _Internal::set_has_voltage(&has_bits);
247 _impl_.voltage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
248 CHK_(ptr);
249 } else {
250 goto handle_unusual;
251 }
252 continue;
253 // optional int32 capacity = 9;
254 case 9:
255 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
256 _Internal::set_has_capacity(&has_bits);
257 _impl_.capacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
258 CHK_(ptr);
259 } else {
260 goto handle_unusual;
261 }
262 continue;
263 default:
264 goto handle_unusual;
265 } // switch
266 handle_unusual:
267 if ((tag == 0) || ((tag & 7) == 4)) {
268 CHK_(ptr);
269 ctx->SetLastTag(tag);
270 goto message_done;
271 }
272 ptr = UnknownFieldParse(
273 tag,
274 _internal_metadata_.mutable_unknown_fields<std::string>(),
275 ptr, ctx);
276 CHK_(ptr != nullptr);
277 } // while
278 message_done:
279 _impl_._has_bits_.Or(has_bits);
280 return ptr;
281 failure:
282 ptr = nullptr;
283 goto message_done;
284 #undef CHK_
285 }
286
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const287 ::uint8_t* BclIrqTriggerFtraceEvent::_InternalSerialize(
288 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
289 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.BclIrqTriggerFtraceEvent)
290 ::uint32_t cached_has_bits = 0;
291 (void) cached_has_bits;
292
293 cached_has_bits = _impl_._has_bits_[0];
294 // optional int32 id = 1;
295 if (cached_has_bits & 0x00000001u) {
296 target = stream->EnsureSpace(target);
297 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
298 }
299
300 // optional int32 throttle = 2;
301 if (cached_has_bits & 0x00000002u) {
302 target = stream->EnsureSpace(target);
303 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_throttle(), target);
304 }
305
306 // optional int32 cpu0_limit = 3;
307 if (cached_has_bits & 0x00000004u) {
308 target = stream->EnsureSpace(target);
309 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_cpu0_limit(), target);
310 }
311
312 // optional int32 cpu1_limit = 4;
313 if (cached_has_bits & 0x00000008u) {
314 target = stream->EnsureSpace(target);
315 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_cpu1_limit(), target);
316 }
317
318 // optional int32 cpu2_limit = 5;
319 if (cached_has_bits & 0x00000010u) {
320 target = stream->EnsureSpace(target);
321 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_cpu2_limit(), target);
322 }
323
324 // optional int32 tpu_limit = 6;
325 if (cached_has_bits & 0x00000020u) {
326 target = stream->EnsureSpace(target);
327 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_tpu_limit(), target);
328 }
329
330 // optional int32 gpu_limit = 7;
331 if (cached_has_bits & 0x00000040u) {
332 target = stream->EnsureSpace(target);
333 target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_gpu_limit(), target);
334 }
335
336 // optional int32 voltage = 8;
337 if (cached_has_bits & 0x00000080u) {
338 target = stream->EnsureSpace(target);
339 target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_voltage(), target);
340 }
341
342 // optional int32 capacity = 9;
343 if (cached_has_bits & 0x00000100u) {
344 target = stream->EnsureSpace(target);
345 target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_capacity(), target);
346 }
347
348 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
349 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
350 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
351 }
352 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.BclIrqTriggerFtraceEvent)
353 return target;
354 }
355
ByteSizeLong() const356 size_t BclIrqTriggerFtraceEvent::ByteSizeLong() const {
357 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.BclIrqTriggerFtraceEvent)
358 size_t total_size = 0;
359
360 ::uint32_t cached_has_bits = 0;
361 // Prevent compiler warnings about cached_has_bits being unused
362 (void) cached_has_bits;
363
364 cached_has_bits = _impl_._has_bits_[0];
365 if (cached_has_bits & 0x000000ffu) {
366 // optional int32 id = 1;
367 if (cached_has_bits & 0x00000001u) {
368 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
369 }
370
371 // optional int32 throttle = 2;
372 if (cached_has_bits & 0x00000002u) {
373 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_throttle());
374 }
375
376 // optional int32 cpu0_limit = 3;
377 if (cached_has_bits & 0x00000004u) {
378 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_cpu0_limit());
379 }
380
381 // optional int32 cpu1_limit = 4;
382 if (cached_has_bits & 0x00000008u) {
383 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_cpu1_limit());
384 }
385
386 // optional int32 cpu2_limit = 5;
387 if (cached_has_bits & 0x00000010u) {
388 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_cpu2_limit());
389 }
390
391 // optional int32 tpu_limit = 6;
392 if (cached_has_bits & 0x00000020u) {
393 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_tpu_limit());
394 }
395
396 // optional int32 gpu_limit = 7;
397 if (cached_has_bits & 0x00000040u) {
398 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_gpu_limit());
399 }
400
401 // optional int32 voltage = 8;
402 if (cached_has_bits & 0x00000080u) {
403 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_voltage());
404 }
405
406 }
407 // optional int32 capacity = 9;
408 if (cached_has_bits & 0x00000100u) {
409 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_capacity());
410 }
411
412 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
413 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
414 }
415 int cached_size = ::_pbi::ToCachedSize(total_size);
416 SetCachedSize(cached_size);
417 return total_size;
418 }
419
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)420 void BclIrqTriggerFtraceEvent::CheckTypeAndMergeFrom(
421 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
422 MergeFrom(*::_pbi::DownCast<const BclIrqTriggerFtraceEvent*>(
423 &from));
424 }
425
MergeFrom(const BclIrqTriggerFtraceEvent & from)426 void BclIrqTriggerFtraceEvent::MergeFrom(const BclIrqTriggerFtraceEvent& from) {
427 BclIrqTriggerFtraceEvent* const _this = this;
428 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.BclIrqTriggerFtraceEvent)
429 GOOGLE_DCHECK_NE(&from, _this);
430 ::uint32_t cached_has_bits = 0;
431 (void) cached_has_bits;
432
433 cached_has_bits = from._impl_._has_bits_[0];
434 if (cached_has_bits & 0x000000ffu) {
435 if (cached_has_bits & 0x00000001u) {
436 _this->_impl_.id_ = from._impl_.id_;
437 }
438 if (cached_has_bits & 0x00000002u) {
439 _this->_impl_.throttle_ = from._impl_.throttle_;
440 }
441 if (cached_has_bits & 0x00000004u) {
442 _this->_impl_.cpu0_limit_ = from._impl_.cpu0_limit_;
443 }
444 if (cached_has_bits & 0x00000008u) {
445 _this->_impl_.cpu1_limit_ = from._impl_.cpu1_limit_;
446 }
447 if (cached_has_bits & 0x00000010u) {
448 _this->_impl_.cpu2_limit_ = from._impl_.cpu2_limit_;
449 }
450 if (cached_has_bits & 0x00000020u) {
451 _this->_impl_.tpu_limit_ = from._impl_.tpu_limit_;
452 }
453 if (cached_has_bits & 0x00000040u) {
454 _this->_impl_.gpu_limit_ = from._impl_.gpu_limit_;
455 }
456 if (cached_has_bits & 0x00000080u) {
457 _this->_impl_.voltage_ = from._impl_.voltage_;
458 }
459 _this->_impl_._has_bits_[0] |= cached_has_bits;
460 }
461 if (cached_has_bits & 0x00000100u) {
462 _this->_internal_set_capacity(from._internal_capacity());
463 }
464 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
465 }
466
CopyFrom(const BclIrqTriggerFtraceEvent & from)467 void BclIrqTriggerFtraceEvent::CopyFrom(const BclIrqTriggerFtraceEvent& from) {
468 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.BclIrqTriggerFtraceEvent)
469 if (&from == this) return;
470 Clear();
471 MergeFrom(from);
472 }
473
IsInitialized() const474 bool BclIrqTriggerFtraceEvent::IsInitialized() const {
475 return true;
476 }
477
InternalSwap(BclIrqTriggerFtraceEvent * other)478 void BclIrqTriggerFtraceEvent::InternalSwap(BclIrqTriggerFtraceEvent* other) {
479 using std::swap;
480 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
481 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
482 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
483 PROTOBUF_FIELD_OFFSET(BclIrqTriggerFtraceEvent, _impl_.capacity_)
484 + sizeof(BclIrqTriggerFtraceEvent::_impl_.capacity_) // NOLINT
485 - PROTOBUF_FIELD_OFFSET(BclIrqTriggerFtraceEvent, _impl_.id_)>(
486 reinterpret_cast<char*>(&_impl_.id_),
487 reinterpret_cast<char*>(&other->_impl_.id_));
488 }
489
GetTypeName() const490 std::string BclIrqTriggerFtraceEvent::GetTypeName() const {
491 return "perfetto.protos.BclIrqTriggerFtraceEvent";
492 }
493
494
495 // @@protoc_insertion_point(namespace_scope)
496 } // namespace protos
497 } // namespace perfetto
498 PROTOBUF_NAMESPACE_OPEN
499 template<> PROTOBUF_NOINLINE ::perfetto::protos::BclIrqTriggerFtraceEvent*
CreateMaybeMessage(Arena * arena)500 Arena::CreateMaybeMessage< ::perfetto::protos::BclIrqTriggerFtraceEvent >(Arena* arena) {
501 return Arena::CreateMessageInternal< ::perfetto::protos::BclIrqTriggerFtraceEvent >(arena);
502 }
503 PROTOBUF_NAMESPACE_CLOSE
504
505 // @@protoc_insertion_point(global_scope)
506 #include <google/protobuf/port_undef.inc>
507