1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/signal.proto
3 
4 #include "protos/perfetto/trace/ftrace/signal.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 {
SignalDeliverFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SignalDeliverFtraceEvent::SignalDeliverFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.sa_flags_)*/::uint64_t{0u}
28   , /*decltype(_impl_.code_)*/0
29   , /*decltype(_impl_.sig_)*/0} {}
30 struct SignalDeliverFtraceEventDefaultTypeInternal {
SignalDeliverFtraceEventDefaultTypeInternalperfetto::protos::SignalDeliverFtraceEventDefaultTypeInternal31   PROTOBUF_CONSTEXPR SignalDeliverFtraceEventDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~SignalDeliverFtraceEventDefaultTypeInternalperfetto::protos::SignalDeliverFtraceEventDefaultTypeInternal33   ~SignalDeliverFtraceEventDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     SignalDeliverFtraceEvent _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SignalDeliverFtraceEventDefaultTypeInternal _SignalDeliverFtraceEvent_default_instance_;
SignalGenerateFtraceEvent(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR SignalGenerateFtraceEvent::SignalGenerateFtraceEvent(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_._has_bits_)*/{}
42   , /*decltype(_impl_._cached_size_)*/{}
43   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
44   , /*decltype(_impl_.code_)*/0
45   , /*decltype(_impl_.group_)*/0
46   , /*decltype(_impl_.pid_)*/0
47   , /*decltype(_impl_.result_)*/0
48   , /*decltype(_impl_.sig_)*/0} {}
49 struct SignalGenerateFtraceEventDefaultTypeInternal {
SignalGenerateFtraceEventDefaultTypeInternalperfetto::protos::SignalGenerateFtraceEventDefaultTypeInternal50   PROTOBUF_CONSTEXPR SignalGenerateFtraceEventDefaultTypeInternal()
51       : _instance(::_pbi::ConstantInitialized{}) {}
~SignalGenerateFtraceEventDefaultTypeInternalperfetto::protos::SignalGenerateFtraceEventDefaultTypeInternal52   ~SignalGenerateFtraceEventDefaultTypeInternal() {}
53   union {  // NOLINT(misc-non-private-member-variables-in-classes)
54     SignalGenerateFtraceEvent _instance;
55   };
56 };
57 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SignalGenerateFtraceEventDefaultTypeInternal _SignalGenerateFtraceEvent_default_instance_;
58 }  // namespace protos
59 }  // namespace perfetto
60 namespace perfetto {
61 namespace protos {
62 
63 // ===================================================================
64 
65 class SignalDeliverFtraceEvent::_Internal {
66  public:
67   using HasBits = decltype(std::declval<SignalDeliverFtraceEvent>()._impl_._has_bits_);
set_has_code(HasBits * has_bits)68   static void set_has_code(HasBits* has_bits) {
69     (*has_bits)[0] |= 2u;
70   }
set_has_sa_flags(HasBits * has_bits)71   static void set_has_sa_flags(HasBits* has_bits) {
72     (*has_bits)[0] |= 1u;
73   }
set_has_sig(HasBits * has_bits)74   static void set_has_sig(HasBits* has_bits) {
75     (*has_bits)[0] |= 4u;
76   }
77 };
78 
SignalDeliverFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)79 SignalDeliverFtraceEvent::SignalDeliverFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
80                          bool is_message_owned)
81   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
82   SharedCtor(arena, is_message_owned);
83   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SignalDeliverFtraceEvent)
84 }
SignalDeliverFtraceEvent(const SignalDeliverFtraceEvent & from)85 SignalDeliverFtraceEvent::SignalDeliverFtraceEvent(const SignalDeliverFtraceEvent& from)
86   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
87   SignalDeliverFtraceEvent* const _this = this; (void)_this;
88   new (&_impl_) Impl_{
89       decltype(_impl_._has_bits_){from._impl_._has_bits_}
90     , /*decltype(_impl_._cached_size_)*/{}
91     , decltype(_impl_.sa_flags_){}
92     , decltype(_impl_.code_){}
93     , decltype(_impl_.sig_){}};
94 
95   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
96   ::memcpy(&_impl_.sa_flags_, &from._impl_.sa_flags_,
97     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.sig_) -
98     reinterpret_cast<char*>(&_impl_.sa_flags_)) + sizeof(_impl_.sig_));
99   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SignalDeliverFtraceEvent)
100 }
101 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)102 inline void SignalDeliverFtraceEvent::SharedCtor(
103     ::_pb::Arena* arena, bool is_message_owned) {
104   (void)arena;
105   (void)is_message_owned;
106   new (&_impl_) Impl_{
107       decltype(_impl_._has_bits_){}
108     , /*decltype(_impl_._cached_size_)*/{}
109     , decltype(_impl_.sa_flags_){::uint64_t{0u}}
110     , decltype(_impl_.code_){0}
111     , decltype(_impl_.sig_){0}
112   };
113 }
114 
~SignalDeliverFtraceEvent()115 SignalDeliverFtraceEvent::~SignalDeliverFtraceEvent() {
116   // @@protoc_insertion_point(destructor:perfetto.protos.SignalDeliverFtraceEvent)
117   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
118   (void)arena;
119     return;
120   }
121   SharedDtor();
122 }
123 
SharedDtor()124 inline void SignalDeliverFtraceEvent::SharedDtor() {
125   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
126 }
127 
SetCachedSize(int size) const128 void SignalDeliverFtraceEvent::SetCachedSize(int size) const {
129   _impl_._cached_size_.Set(size);
130 }
131 
Clear()132 void SignalDeliverFtraceEvent::Clear() {
133 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SignalDeliverFtraceEvent)
134   ::uint32_t cached_has_bits = 0;
135   // Prevent compiler warnings about cached_has_bits being unused
136   (void) cached_has_bits;
137 
138   cached_has_bits = _impl_._has_bits_[0];
139   if (cached_has_bits & 0x00000007u) {
140     ::memset(&_impl_.sa_flags_, 0, static_cast<size_t>(
141         reinterpret_cast<char*>(&_impl_.sig_) -
142         reinterpret_cast<char*>(&_impl_.sa_flags_)) + sizeof(_impl_.sig_));
143   }
144   _impl_._has_bits_.Clear();
145   _internal_metadata_.Clear<std::string>();
146 }
147 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)148 const char* SignalDeliverFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
149 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
150   _Internal::HasBits has_bits{};
151   while (!ctx->Done(&ptr)) {
152     ::uint32_t tag;
153     ptr = ::_pbi::ReadTag(ptr, &tag);
154     switch (tag >> 3) {
155       // optional int32 code = 1;
156       case 1:
157         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
158           _Internal::set_has_code(&has_bits);
159           _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
160           CHK_(ptr);
161         } else {
162           goto handle_unusual;
163         }
164         continue;
165       // optional uint64 sa_flags = 2;
166       case 2:
167         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
168           _Internal::set_has_sa_flags(&has_bits);
169           _impl_.sa_flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
170           CHK_(ptr);
171         } else {
172           goto handle_unusual;
173         }
174         continue;
175       // optional int32 sig = 3;
176       case 3:
177         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
178           _Internal::set_has_sig(&has_bits);
179           _impl_.sig_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
180           CHK_(ptr);
181         } else {
182           goto handle_unusual;
183         }
184         continue;
185       default:
186         goto handle_unusual;
187     }  // switch
188   handle_unusual:
189     if ((tag == 0) || ((tag & 7) == 4)) {
190       CHK_(ptr);
191       ctx->SetLastTag(tag);
192       goto message_done;
193     }
194     ptr = UnknownFieldParse(
195         tag,
196         _internal_metadata_.mutable_unknown_fields<std::string>(),
197         ptr, ctx);
198     CHK_(ptr != nullptr);
199   }  // while
200 message_done:
201   _impl_._has_bits_.Or(has_bits);
202   return ptr;
203 failure:
204   ptr = nullptr;
205   goto message_done;
206 #undef CHK_
207 }
208 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const209 ::uint8_t* SignalDeliverFtraceEvent::_InternalSerialize(
210     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
211   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SignalDeliverFtraceEvent)
212   ::uint32_t cached_has_bits = 0;
213   (void) cached_has_bits;
214 
215   cached_has_bits = _impl_._has_bits_[0];
216   // optional int32 code = 1;
217   if (cached_has_bits & 0x00000002u) {
218     target = stream->EnsureSpace(target);
219     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_code(), target);
220   }
221 
222   // optional uint64 sa_flags = 2;
223   if (cached_has_bits & 0x00000001u) {
224     target = stream->EnsureSpace(target);
225     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_sa_flags(), target);
226   }
227 
228   // optional int32 sig = 3;
229   if (cached_has_bits & 0x00000004u) {
230     target = stream->EnsureSpace(target);
231     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_sig(), target);
232   }
233 
234   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
235     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
236         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
237   }
238   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SignalDeliverFtraceEvent)
239   return target;
240 }
241 
ByteSizeLong() const242 size_t SignalDeliverFtraceEvent::ByteSizeLong() const {
243 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SignalDeliverFtraceEvent)
244   size_t total_size = 0;
245 
246   ::uint32_t cached_has_bits = 0;
247   // Prevent compiler warnings about cached_has_bits being unused
248   (void) cached_has_bits;
249 
250   cached_has_bits = _impl_._has_bits_[0];
251   if (cached_has_bits & 0x00000007u) {
252     // optional uint64 sa_flags = 2;
253     if (cached_has_bits & 0x00000001u) {
254       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_sa_flags());
255     }
256 
257     // optional int32 code = 1;
258     if (cached_has_bits & 0x00000002u) {
259       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_code());
260     }
261 
262     // optional int32 sig = 3;
263     if (cached_has_bits & 0x00000004u) {
264       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_sig());
265     }
266 
267   }
268   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
269     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
270   }
271   int cached_size = ::_pbi::ToCachedSize(total_size);
272   SetCachedSize(cached_size);
273   return total_size;
274 }
275 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)276 void SignalDeliverFtraceEvent::CheckTypeAndMergeFrom(
277     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
278   MergeFrom(*::_pbi::DownCast<const SignalDeliverFtraceEvent*>(
279       &from));
280 }
281 
MergeFrom(const SignalDeliverFtraceEvent & from)282 void SignalDeliverFtraceEvent::MergeFrom(const SignalDeliverFtraceEvent& from) {
283   SignalDeliverFtraceEvent* const _this = this;
284   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SignalDeliverFtraceEvent)
285   GOOGLE_DCHECK_NE(&from, _this);
286   ::uint32_t cached_has_bits = 0;
287   (void) cached_has_bits;
288 
289   cached_has_bits = from._impl_._has_bits_[0];
290   if (cached_has_bits & 0x00000007u) {
291     if (cached_has_bits & 0x00000001u) {
292       _this->_impl_.sa_flags_ = from._impl_.sa_flags_;
293     }
294     if (cached_has_bits & 0x00000002u) {
295       _this->_impl_.code_ = from._impl_.code_;
296     }
297     if (cached_has_bits & 0x00000004u) {
298       _this->_impl_.sig_ = from._impl_.sig_;
299     }
300     _this->_impl_._has_bits_[0] |= cached_has_bits;
301   }
302   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
303 }
304 
CopyFrom(const SignalDeliverFtraceEvent & from)305 void SignalDeliverFtraceEvent::CopyFrom(const SignalDeliverFtraceEvent& from) {
306 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SignalDeliverFtraceEvent)
307   if (&from == this) return;
308   Clear();
309   MergeFrom(from);
310 }
311 
IsInitialized() const312 bool SignalDeliverFtraceEvent::IsInitialized() const {
313   return true;
314 }
315 
InternalSwap(SignalDeliverFtraceEvent * other)316 void SignalDeliverFtraceEvent::InternalSwap(SignalDeliverFtraceEvent* other) {
317   using std::swap;
318   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
319   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
320   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
321       PROTOBUF_FIELD_OFFSET(SignalDeliverFtraceEvent, _impl_.sig_)
322       + sizeof(SignalDeliverFtraceEvent::_impl_.sig_)  // NOLINT
323       - PROTOBUF_FIELD_OFFSET(SignalDeliverFtraceEvent, _impl_.sa_flags_)>(
324           reinterpret_cast<char*>(&_impl_.sa_flags_),
325           reinterpret_cast<char*>(&other->_impl_.sa_flags_));
326 }
327 
GetTypeName() const328 std::string SignalDeliverFtraceEvent::GetTypeName() const {
329   return "perfetto.protos.SignalDeliverFtraceEvent";
330 }
331 
332 
333 // ===================================================================
334 
335 class SignalGenerateFtraceEvent::_Internal {
336  public:
337   using HasBits = decltype(std::declval<SignalGenerateFtraceEvent>()._impl_._has_bits_);
set_has_code(HasBits * has_bits)338   static void set_has_code(HasBits* has_bits) {
339     (*has_bits)[0] |= 2u;
340   }
set_has_comm(HasBits * has_bits)341   static void set_has_comm(HasBits* has_bits) {
342     (*has_bits)[0] |= 1u;
343   }
set_has_group(HasBits * has_bits)344   static void set_has_group(HasBits* has_bits) {
345     (*has_bits)[0] |= 4u;
346   }
set_has_pid(HasBits * has_bits)347   static void set_has_pid(HasBits* has_bits) {
348     (*has_bits)[0] |= 8u;
349   }
set_has_result(HasBits * has_bits)350   static void set_has_result(HasBits* has_bits) {
351     (*has_bits)[0] |= 16u;
352   }
set_has_sig(HasBits * has_bits)353   static void set_has_sig(HasBits* has_bits) {
354     (*has_bits)[0] |= 32u;
355   }
356 };
357 
SignalGenerateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)358 SignalGenerateFtraceEvent::SignalGenerateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
359                          bool is_message_owned)
360   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
361   SharedCtor(arena, is_message_owned);
362   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SignalGenerateFtraceEvent)
363 }
SignalGenerateFtraceEvent(const SignalGenerateFtraceEvent & from)364 SignalGenerateFtraceEvent::SignalGenerateFtraceEvent(const SignalGenerateFtraceEvent& from)
365   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
366   SignalGenerateFtraceEvent* const _this = this; (void)_this;
367   new (&_impl_) Impl_{
368       decltype(_impl_._has_bits_){from._impl_._has_bits_}
369     , /*decltype(_impl_._cached_size_)*/{}
370     , decltype(_impl_.comm_){}
371     , decltype(_impl_.code_){}
372     , decltype(_impl_.group_){}
373     , decltype(_impl_.pid_){}
374     , decltype(_impl_.result_){}
375     , decltype(_impl_.sig_){}};
376 
377   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
378   _impl_.comm_.InitDefault();
379   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
380     _impl_.comm_.Set("", GetArenaForAllocation());
381   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
382   if (from._internal_has_comm()) {
383     _this->_impl_.comm_.Set(from._internal_comm(),
384       _this->GetArenaForAllocation());
385   }
386   ::memcpy(&_impl_.code_, &from._impl_.code_,
387     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.sig_) -
388     reinterpret_cast<char*>(&_impl_.code_)) + sizeof(_impl_.sig_));
389   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SignalGenerateFtraceEvent)
390 }
391 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)392 inline void SignalGenerateFtraceEvent::SharedCtor(
393     ::_pb::Arena* arena, bool is_message_owned) {
394   (void)arena;
395   (void)is_message_owned;
396   new (&_impl_) Impl_{
397       decltype(_impl_._has_bits_){}
398     , /*decltype(_impl_._cached_size_)*/{}
399     , decltype(_impl_.comm_){}
400     , decltype(_impl_.code_){0}
401     , decltype(_impl_.group_){0}
402     , decltype(_impl_.pid_){0}
403     , decltype(_impl_.result_){0}
404     , decltype(_impl_.sig_){0}
405   };
406   _impl_.comm_.InitDefault();
407   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
408     _impl_.comm_.Set("", GetArenaForAllocation());
409   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
410 }
411 
~SignalGenerateFtraceEvent()412 SignalGenerateFtraceEvent::~SignalGenerateFtraceEvent() {
413   // @@protoc_insertion_point(destructor:perfetto.protos.SignalGenerateFtraceEvent)
414   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
415   (void)arena;
416     return;
417   }
418   SharedDtor();
419 }
420 
SharedDtor()421 inline void SignalGenerateFtraceEvent::SharedDtor() {
422   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
423   _impl_.comm_.Destroy();
424 }
425 
SetCachedSize(int size) const426 void SignalGenerateFtraceEvent::SetCachedSize(int size) const {
427   _impl_._cached_size_.Set(size);
428 }
429 
Clear()430 void SignalGenerateFtraceEvent::Clear() {
431 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SignalGenerateFtraceEvent)
432   ::uint32_t cached_has_bits = 0;
433   // Prevent compiler warnings about cached_has_bits being unused
434   (void) cached_has_bits;
435 
436   cached_has_bits = _impl_._has_bits_[0];
437   if (cached_has_bits & 0x00000001u) {
438     _impl_.comm_.ClearNonDefaultToEmpty();
439   }
440   if (cached_has_bits & 0x0000003eu) {
441     ::memset(&_impl_.code_, 0, static_cast<size_t>(
442         reinterpret_cast<char*>(&_impl_.sig_) -
443         reinterpret_cast<char*>(&_impl_.code_)) + sizeof(_impl_.sig_));
444   }
445   _impl_._has_bits_.Clear();
446   _internal_metadata_.Clear<std::string>();
447 }
448 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)449 const char* SignalGenerateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
450 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
451   _Internal::HasBits has_bits{};
452   while (!ctx->Done(&ptr)) {
453     ::uint32_t tag;
454     ptr = ::_pbi::ReadTag(ptr, &tag);
455     switch (tag >> 3) {
456       // optional int32 code = 1;
457       case 1:
458         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
459           _Internal::set_has_code(&has_bits);
460           _impl_.code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
461           CHK_(ptr);
462         } else {
463           goto handle_unusual;
464         }
465         continue;
466       // optional string comm = 2;
467       case 2:
468         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
469           auto str = _internal_mutable_comm();
470           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
471           CHK_(ptr);
472         } else {
473           goto handle_unusual;
474         }
475         continue;
476       // optional int32 group = 3;
477       case 3:
478         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
479           _Internal::set_has_group(&has_bits);
480           _impl_.group_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
481           CHK_(ptr);
482         } else {
483           goto handle_unusual;
484         }
485         continue;
486       // optional int32 pid = 4;
487       case 4:
488         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
489           _Internal::set_has_pid(&has_bits);
490           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
491           CHK_(ptr);
492         } else {
493           goto handle_unusual;
494         }
495         continue;
496       // optional int32 result = 5;
497       case 5:
498         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
499           _Internal::set_has_result(&has_bits);
500           _impl_.result_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
501           CHK_(ptr);
502         } else {
503           goto handle_unusual;
504         }
505         continue;
506       // optional int32 sig = 6;
507       case 6:
508         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
509           _Internal::set_has_sig(&has_bits);
510           _impl_.sig_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
511           CHK_(ptr);
512         } else {
513           goto handle_unusual;
514         }
515         continue;
516       default:
517         goto handle_unusual;
518     }  // switch
519   handle_unusual:
520     if ((tag == 0) || ((tag & 7) == 4)) {
521       CHK_(ptr);
522       ctx->SetLastTag(tag);
523       goto message_done;
524     }
525     ptr = UnknownFieldParse(
526         tag,
527         _internal_metadata_.mutable_unknown_fields<std::string>(),
528         ptr, ctx);
529     CHK_(ptr != nullptr);
530   }  // while
531 message_done:
532   _impl_._has_bits_.Or(has_bits);
533   return ptr;
534 failure:
535   ptr = nullptr;
536   goto message_done;
537 #undef CHK_
538 }
539 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const540 ::uint8_t* SignalGenerateFtraceEvent::_InternalSerialize(
541     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
542   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SignalGenerateFtraceEvent)
543   ::uint32_t cached_has_bits = 0;
544   (void) cached_has_bits;
545 
546   cached_has_bits = _impl_._has_bits_[0];
547   // optional int32 code = 1;
548   if (cached_has_bits & 0x00000002u) {
549     target = stream->EnsureSpace(target);
550     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_code(), target);
551   }
552 
553   // optional string comm = 2;
554   if (cached_has_bits & 0x00000001u) {
555     target = stream->WriteStringMaybeAliased(
556         2, this->_internal_comm(), target);
557   }
558 
559   // optional int32 group = 3;
560   if (cached_has_bits & 0x00000004u) {
561     target = stream->EnsureSpace(target);
562     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_group(), target);
563   }
564 
565   // optional int32 pid = 4;
566   if (cached_has_bits & 0x00000008u) {
567     target = stream->EnsureSpace(target);
568     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_pid(), target);
569   }
570 
571   // optional int32 result = 5;
572   if (cached_has_bits & 0x00000010u) {
573     target = stream->EnsureSpace(target);
574     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_result(), target);
575   }
576 
577   // optional int32 sig = 6;
578   if (cached_has_bits & 0x00000020u) {
579     target = stream->EnsureSpace(target);
580     target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_sig(), target);
581   }
582 
583   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
584     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
585         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
586   }
587   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SignalGenerateFtraceEvent)
588   return target;
589 }
590 
ByteSizeLong() const591 size_t SignalGenerateFtraceEvent::ByteSizeLong() const {
592 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SignalGenerateFtraceEvent)
593   size_t total_size = 0;
594 
595   ::uint32_t cached_has_bits = 0;
596   // Prevent compiler warnings about cached_has_bits being unused
597   (void) cached_has_bits;
598 
599   cached_has_bits = _impl_._has_bits_[0];
600   if (cached_has_bits & 0x0000003fu) {
601     // optional string comm = 2;
602     if (cached_has_bits & 0x00000001u) {
603       total_size += 1 +
604         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
605           this->_internal_comm());
606     }
607 
608     // optional int32 code = 1;
609     if (cached_has_bits & 0x00000002u) {
610       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_code());
611     }
612 
613     // optional int32 group = 3;
614     if (cached_has_bits & 0x00000004u) {
615       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_group());
616     }
617 
618     // optional int32 pid = 4;
619     if (cached_has_bits & 0x00000008u) {
620       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
621     }
622 
623     // optional int32 result = 5;
624     if (cached_has_bits & 0x00000010u) {
625       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_result());
626     }
627 
628     // optional int32 sig = 6;
629     if (cached_has_bits & 0x00000020u) {
630       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_sig());
631     }
632 
633   }
634   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
635     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
636   }
637   int cached_size = ::_pbi::ToCachedSize(total_size);
638   SetCachedSize(cached_size);
639   return total_size;
640 }
641 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)642 void SignalGenerateFtraceEvent::CheckTypeAndMergeFrom(
643     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
644   MergeFrom(*::_pbi::DownCast<const SignalGenerateFtraceEvent*>(
645       &from));
646 }
647 
MergeFrom(const SignalGenerateFtraceEvent & from)648 void SignalGenerateFtraceEvent::MergeFrom(const SignalGenerateFtraceEvent& from) {
649   SignalGenerateFtraceEvent* const _this = this;
650   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SignalGenerateFtraceEvent)
651   GOOGLE_DCHECK_NE(&from, _this);
652   ::uint32_t cached_has_bits = 0;
653   (void) cached_has_bits;
654 
655   cached_has_bits = from._impl_._has_bits_[0];
656   if (cached_has_bits & 0x0000003fu) {
657     if (cached_has_bits & 0x00000001u) {
658       _this->_internal_set_comm(from._internal_comm());
659     }
660     if (cached_has_bits & 0x00000002u) {
661       _this->_impl_.code_ = from._impl_.code_;
662     }
663     if (cached_has_bits & 0x00000004u) {
664       _this->_impl_.group_ = from._impl_.group_;
665     }
666     if (cached_has_bits & 0x00000008u) {
667       _this->_impl_.pid_ = from._impl_.pid_;
668     }
669     if (cached_has_bits & 0x00000010u) {
670       _this->_impl_.result_ = from._impl_.result_;
671     }
672     if (cached_has_bits & 0x00000020u) {
673       _this->_impl_.sig_ = from._impl_.sig_;
674     }
675     _this->_impl_._has_bits_[0] |= cached_has_bits;
676   }
677   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
678 }
679 
CopyFrom(const SignalGenerateFtraceEvent & from)680 void SignalGenerateFtraceEvent::CopyFrom(const SignalGenerateFtraceEvent& from) {
681 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SignalGenerateFtraceEvent)
682   if (&from == this) return;
683   Clear();
684   MergeFrom(from);
685 }
686 
IsInitialized() const687 bool SignalGenerateFtraceEvent::IsInitialized() const {
688   return true;
689 }
690 
InternalSwap(SignalGenerateFtraceEvent * other)691 void SignalGenerateFtraceEvent::InternalSwap(SignalGenerateFtraceEvent* other) {
692   using std::swap;
693   auto* lhs_arena = GetArenaForAllocation();
694   auto* rhs_arena = other->GetArenaForAllocation();
695   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
696   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
697   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
698       &_impl_.comm_, lhs_arena,
699       &other->_impl_.comm_, rhs_arena
700   );
701   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
702       PROTOBUF_FIELD_OFFSET(SignalGenerateFtraceEvent, _impl_.sig_)
703       + sizeof(SignalGenerateFtraceEvent::_impl_.sig_)  // NOLINT
704       - PROTOBUF_FIELD_OFFSET(SignalGenerateFtraceEvent, _impl_.code_)>(
705           reinterpret_cast<char*>(&_impl_.code_),
706           reinterpret_cast<char*>(&other->_impl_.code_));
707 }
708 
GetTypeName() const709 std::string SignalGenerateFtraceEvent::GetTypeName() const {
710   return "perfetto.protos.SignalGenerateFtraceEvent";
711 }
712 
713 
714 // @@protoc_insertion_point(namespace_scope)
715 }  // namespace protos
716 }  // namespace perfetto
717 PROTOBUF_NAMESPACE_OPEN
718 template<> PROTOBUF_NOINLINE ::perfetto::protos::SignalDeliverFtraceEvent*
CreateMaybeMessage(Arena * arena)719 Arena::CreateMaybeMessage< ::perfetto::protos::SignalDeliverFtraceEvent >(Arena* arena) {
720   return Arena::CreateMessageInternal< ::perfetto::protos::SignalDeliverFtraceEvent >(arena);
721 }
722 template<> PROTOBUF_NOINLINE ::perfetto::protos::SignalGenerateFtraceEvent*
CreateMaybeMessage(Arena * arena)723 Arena::CreateMaybeMessage< ::perfetto::protos::SignalGenerateFtraceEvent >(Arena* arena) {
724   return Arena::CreateMessageInternal< ::perfetto::protos::SignalGenerateFtraceEvent >(arena);
725 }
726 PROTOBUF_NAMESPACE_CLOSE
727 
728 // @@protoc_insertion_point(global_scope)
729 #include <google/protobuf/port_undef.inc>
730