1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/net.proto
3 
4 #include "protos/perfetto/trace/ftrace/net.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 {
NetifReceiveSkbFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR NetifReceiveSkbFtraceEvent::NetifReceiveSkbFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.skbaddr_)*/::uint64_t{0u}
29   , /*decltype(_impl_.len_)*/0u} {}
30 struct NetifReceiveSkbFtraceEventDefaultTypeInternal {
NetifReceiveSkbFtraceEventDefaultTypeInternalperfetto::protos::NetifReceiveSkbFtraceEventDefaultTypeInternal31   PROTOBUF_CONSTEXPR NetifReceiveSkbFtraceEventDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~NetifReceiveSkbFtraceEventDefaultTypeInternalperfetto::protos::NetifReceiveSkbFtraceEventDefaultTypeInternal33   ~NetifReceiveSkbFtraceEventDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     NetifReceiveSkbFtraceEvent _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetifReceiveSkbFtraceEventDefaultTypeInternal _NetifReceiveSkbFtraceEvent_default_instance_;
NetDevXmitFtraceEvent(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR NetDevXmitFtraceEvent::NetDevXmitFtraceEvent(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_._has_bits_)*/{}
42   , /*decltype(_impl_._cached_size_)*/{}
43   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
44   , /*decltype(_impl_.len_)*/0u
45   , /*decltype(_impl_.rc_)*/0
46   , /*decltype(_impl_.skbaddr_)*/::uint64_t{0u}} {}
47 struct NetDevXmitFtraceEventDefaultTypeInternal {
NetDevXmitFtraceEventDefaultTypeInternalperfetto::protos::NetDevXmitFtraceEventDefaultTypeInternal48   PROTOBUF_CONSTEXPR NetDevXmitFtraceEventDefaultTypeInternal()
49       : _instance(::_pbi::ConstantInitialized{}) {}
~NetDevXmitFtraceEventDefaultTypeInternalperfetto::protos::NetDevXmitFtraceEventDefaultTypeInternal50   ~NetDevXmitFtraceEventDefaultTypeInternal() {}
51   union {  // NOLINT(misc-non-private-member-variables-in-classes)
52     NetDevXmitFtraceEvent _instance;
53   };
54 };
55 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NetDevXmitFtraceEventDefaultTypeInternal _NetDevXmitFtraceEvent_default_instance_;
NapiGroReceiveEntryFtraceEvent(::_pbi::ConstantInitialized)56 PROTOBUF_CONSTEXPR NapiGroReceiveEntryFtraceEvent::NapiGroReceiveEntryFtraceEvent(
57     ::_pbi::ConstantInitialized): _impl_{
58     /*decltype(_impl_._has_bits_)*/{}
59   , /*decltype(_impl_._cached_size_)*/{}
60   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
61   , /*decltype(_impl_.data_len_)*/0u
62   , /*decltype(_impl_.gso_size_)*/0u
63   , /*decltype(_impl_.gso_type_)*/0u
64   , /*decltype(_impl_.hash_)*/0u
65   , /*decltype(_impl_.ip_summed_)*/0u
66   , /*decltype(_impl_.l4_hash_)*/0u
67   , /*decltype(_impl_.len_)*/0u
68   , /*decltype(_impl_.mac_header_)*/0
69   , /*decltype(_impl_.mac_header_valid_)*/0u
70   , /*decltype(_impl_.napi_id_)*/0u
71   , /*decltype(_impl_.nr_frags_)*/0u
72   , /*decltype(_impl_.protocol_)*/0u
73   , /*decltype(_impl_.skbaddr_)*/::uint64_t{0u}
74   , /*decltype(_impl_.queue_mapping_)*/0u
75   , /*decltype(_impl_.truesize_)*/0u
76   , /*decltype(_impl_.vlan_proto_)*/0u
77   , /*decltype(_impl_.vlan_tagged_)*/0u
78   , /*decltype(_impl_.vlan_tci_)*/0u} {}
79 struct NapiGroReceiveEntryFtraceEventDefaultTypeInternal {
NapiGroReceiveEntryFtraceEventDefaultTypeInternalperfetto::protos::NapiGroReceiveEntryFtraceEventDefaultTypeInternal80   PROTOBUF_CONSTEXPR NapiGroReceiveEntryFtraceEventDefaultTypeInternal()
81       : _instance(::_pbi::ConstantInitialized{}) {}
~NapiGroReceiveEntryFtraceEventDefaultTypeInternalperfetto::protos::NapiGroReceiveEntryFtraceEventDefaultTypeInternal82   ~NapiGroReceiveEntryFtraceEventDefaultTypeInternal() {}
83   union {  // NOLINT(misc-non-private-member-variables-in-classes)
84     NapiGroReceiveEntryFtraceEvent _instance;
85   };
86 };
87 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NapiGroReceiveEntryFtraceEventDefaultTypeInternal _NapiGroReceiveEntryFtraceEvent_default_instance_;
NapiGroReceiveExitFtraceEvent(::_pbi::ConstantInitialized)88 PROTOBUF_CONSTEXPR NapiGroReceiveExitFtraceEvent::NapiGroReceiveExitFtraceEvent(
89     ::_pbi::ConstantInitialized): _impl_{
90     /*decltype(_impl_._has_bits_)*/{}
91   , /*decltype(_impl_._cached_size_)*/{}
92   , /*decltype(_impl_.ret_)*/0} {}
93 struct NapiGroReceiveExitFtraceEventDefaultTypeInternal {
NapiGroReceiveExitFtraceEventDefaultTypeInternalperfetto::protos::NapiGroReceiveExitFtraceEventDefaultTypeInternal94   PROTOBUF_CONSTEXPR NapiGroReceiveExitFtraceEventDefaultTypeInternal()
95       : _instance(::_pbi::ConstantInitialized{}) {}
~NapiGroReceiveExitFtraceEventDefaultTypeInternalperfetto::protos::NapiGroReceiveExitFtraceEventDefaultTypeInternal96   ~NapiGroReceiveExitFtraceEventDefaultTypeInternal() {}
97   union {  // NOLINT(misc-non-private-member-variables-in-classes)
98     NapiGroReceiveExitFtraceEvent _instance;
99   };
100 };
101 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 NapiGroReceiveExitFtraceEventDefaultTypeInternal _NapiGroReceiveExitFtraceEvent_default_instance_;
102 }  // namespace protos
103 }  // namespace perfetto
104 namespace perfetto {
105 namespace protos {
106 
107 // ===================================================================
108 
109 class NetifReceiveSkbFtraceEvent::_Internal {
110  public:
111   using HasBits = decltype(std::declval<NetifReceiveSkbFtraceEvent>()._impl_._has_bits_);
set_has_len(HasBits * has_bits)112   static void set_has_len(HasBits* has_bits) {
113     (*has_bits)[0] |= 4u;
114   }
set_has_name(HasBits * has_bits)115   static void set_has_name(HasBits* has_bits) {
116     (*has_bits)[0] |= 1u;
117   }
set_has_skbaddr(HasBits * has_bits)118   static void set_has_skbaddr(HasBits* has_bits) {
119     (*has_bits)[0] |= 2u;
120   }
121 };
122 
NetifReceiveSkbFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)123 NetifReceiveSkbFtraceEvent::NetifReceiveSkbFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
124                          bool is_message_owned)
125   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
126   SharedCtor(arena, is_message_owned);
127   // @@protoc_insertion_point(arena_constructor:perfetto.protos.NetifReceiveSkbFtraceEvent)
128 }
NetifReceiveSkbFtraceEvent(const NetifReceiveSkbFtraceEvent & from)129 NetifReceiveSkbFtraceEvent::NetifReceiveSkbFtraceEvent(const NetifReceiveSkbFtraceEvent& from)
130   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
131   NetifReceiveSkbFtraceEvent* const _this = this; (void)_this;
132   new (&_impl_) Impl_{
133       decltype(_impl_._has_bits_){from._impl_._has_bits_}
134     , /*decltype(_impl_._cached_size_)*/{}
135     , decltype(_impl_.name_){}
136     , decltype(_impl_.skbaddr_){}
137     , decltype(_impl_.len_){}};
138 
139   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
140   _impl_.name_.InitDefault();
141   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
142     _impl_.name_.Set("", GetArenaForAllocation());
143   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
144   if (from._internal_has_name()) {
145     _this->_impl_.name_.Set(from._internal_name(),
146       _this->GetArenaForAllocation());
147   }
148   ::memcpy(&_impl_.skbaddr_, &from._impl_.skbaddr_,
149     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.len_) -
150     reinterpret_cast<char*>(&_impl_.skbaddr_)) + sizeof(_impl_.len_));
151   // @@protoc_insertion_point(copy_constructor:perfetto.protos.NetifReceiveSkbFtraceEvent)
152 }
153 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)154 inline void NetifReceiveSkbFtraceEvent::SharedCtor(
155     ::_pb::Arena* arena, bool is_message_owned) {
156   (void)arena;
157   (void)is_message_owned;
158   new (&_impl_) Impl_{
159       decltype(_impl_._has_bits_){}
160     , /*decltype(_impl_._cached_size_)*/{}
161     , decltype(_impl_.name_){}
162     , decltype(_impl_.skbaddr_){::uint64_t{0u}}
163     , decltype(_impl_.len_){0u}
164   };
165   _impl_.name_.InitDefault();
166   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
167     _impl_.name_.Set("", GetArenaForAllocation());
168   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
169 }
170 
~NetifReceiveSkbFtraceEvent()171 NetifReceiveSkbFtraceEvent::~NetifReceiveSkbFtraceEvent() {
172   // @@protoc_insertion_point(destructor:perfetto.protos.NetifReceiveSkbFtraceEvent)
173   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
174   (void)arena;
175     return;
176   }
177   SharedDtor();
178 }
179 
SharedDtor()180 inline void NetifReceiveSkbFtraceEvent::SharedDtor() {
181   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
182   _impl_.name_.Destroy();
183 }
184 
SetCachedSize(int size) const185 void NetifReceiveSkbFtraceEvent::SetCachedSize(int size) const {
186   _impl_._cached_size_.Set(size);
187 }
188 
Clear()189 void NetifReceiveSkbFtraceEvent::Clear() {
190 // @@protoc_insertion_point(message_clear_start:perfetto.protos.NetifReceiveSkbFtraceEvent)
191   ::uint32_t cached_has_bits = 0;
192   // Prevent compiler warnings about cached_has_bits being unused
193   (void) cached_has_bits;
194 
195   cached_has_bits = _impl_._has_bits_[0];
196   if (cached_has_bits & 0x00000001u) {
197     _impl_.name_.ClearNonDefaultToEmpty();
198   }
199   if (cached_has_bits & 0x00000006u) {
200     ::memset(&_impl_.skbaddr_, 0, static_cast<size_t>(
201         reinterpret_cast<char*>(&_impl_.len_) -
202         reinterpret_cast<char*>(&_impl_.skbaddr_)) + sizeof(_impl_.len_));
203   }
204   _impl_._has_bits_.Clear();
205   _internal_metadata_.Clear<std::string>();
206 }
207 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)208 const char* NetifReceiveSkbFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
209 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
210   _Internal::HasBits has_bits{};
211   while (!ctx->Done(&ptr)) {
212     ::uint32_t tag;
213     ptr = ::_pbi::ReadTag(ptr, &tag);
214     switch (tag >> 3) {
215       // optional uint32 len = 1;
216       case 1:
217         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
218           _Internal::set_has_len(&has_bits);
219           _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
220           CHK_(ptr);
221         } else {
222           goto handle_unusual;
223         }
224         continue;
225       // optional string name = 2;
226       case 2:
227         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
228           auto str = _internal_mutable_name();
229           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
230           CHK_(ptr);
231         } else {
232           goto handle_unusual;
233         }
234         continue;
235       // optional uint64 skbaddr = 3;
236       case 3:
237         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
238           _Internal::set_has_skbaddr(&has_bits);
239           _impl_.skbaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
240           CHK_(ptr);
241         } else {
242           goto handle_unusual;
243         }
244         continue;
245       default:
246         goto handle_unusual;
247     }  // switch
248   handle_unusual:
249     if ((tag == 0) || ((tag & 7) == 4)) {
250       CHK_(ptr);
251       ctx->SetLastTag(tag);
252       goto message_done;
253     }
254     ptr = UnknownFieldParse(
255         tag,
256         _internal_metadata_.mutable_unknown_fields<std::string>(),
257         ptr, ctx);
258     CHK_(ptr != nullptr);
259   }  // while
260 message_done:
261   _impl_._has_bits_.Or(has_bits);
262   return ptr;
263 failure:
264   ptr = nullptr;
265   goto message_done;
266 #undef CHK_
267 }
268 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const269 ::uint8_t* NetifReceiveSkbFtraceEvent::_InternalSerialize(
270     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
271   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.NetifReceiveSkbFtraceEvent)
272   ::uint32_t cached_has_bits = 0;
273   (void) cached_has_bits;
274 
275   cached_has_bits = _impl_._has_bits_[0];
276   // optional uint32 len = 1;
277   if (cached_has_bits & 0x00000004u) {
278     target = stream->EnsureSpace(target);
279     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_len(), target);
280   }
281 
282   // optional string name = 2;
283   if (cached_has_bits & 0x00000001u) {
284     target = stream->WriteStringMaybeAliased(
285         2, this->_internal_name(), target);
286   }
287 
288   // optional uint64 skbaddr = 3;
289   if (cached_has_bits & 0x00000002u) {
290     target = stream->EnsureSpace(target);
291     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_skbaddr(), target);
292   }
293 
294   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
295     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
296         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
297   }
298   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.NetifReceiveSkbFtraceEvent)
299   return target;
300 }
301 
ByteSizeLong() const302 size_t NetifReceiveSkbFtraceEvent::ByteSizeLong() const {
303 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.NetifReceiveSkbFtraceEvent)
304   size_t total_size = 0;
305 
306   ::uint32_t cached_has_bits = 0;
307   // Prevent compiler warnings about cached_has_bits being unused
308   (void) cached_has_bits;
309 
310   cached_has_bits = _impl_._has_bits_[0];
311   if (cached_has_bits & 0x00000007u) {
312     // optional string name = 2;
313     if (cached_has_bits & 0x00000001u) {
314       total_size += 1 +
315         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
316           this->_internal_name());
317     }
318 
319     // optional uint64 skbaddr = 3;
320     if (cached_has_bits & 0x00000002u) {
321       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_skbaddr());
322     }
323 
324     // optional uint32 len = 1;
325     if (cached_has_bits & 0x00000004u) {
326       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
327     }
328 
329   }
330   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
331     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
332   }
333   int cached_size = ::_pbi::ToCachedSize(total_size);
334   SetCachedSize(cached_size);
335   return total_size;
336 }
337 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)338 void NetifReceiveSkbFtraceEvent::CheckTypeAndMergeFrom(
339     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
340   MergeFrom(*::_pbi::DownCast<const NetifReceiveSkbFtraceEvent*>(
341       &from));
342 }
343 
MergeFrom(const NetifReceiveSkbFtraceEvent & from)344 void NetifReceiveSkbFtraceEvent::MergeFrom(const NetifReceiveSkbFtraceEvent& from) {
345   NetifReceiveSkbFtraceEvent* const _this = this;
346   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.NetifReceiveSkbFtraceEvent)
347   GOOGLE_DCHECK_NE(&from, _this);
348   ::uint32_t cached_has_bits = 0;
349   (void) cached_has_bits;
350 
351   cached_has_bits = from._impl_._has_bits_[0];
352   if (cached_has_bits & 0x00000007u) {
353     if (cached_has_bits & 0x00000001u) {
354       _this->_internal_set_name(from._internal_name());
355     }
356     if (cached_has_bits & 0x00000002u) {
357       _this->_impl_.skbaddr_ = from._impl_.skbaddr_;
358     }
359     if (cached_has_bits & 0x00000004u) {
360       _this->_impl_.len_ = from._impl_.len_;
361     }
362     _this->_impl_._has_bits_[0] |= cached_has_bits;
363   }
364   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
365 }
366 
CopyFrom(const NetifReceiveSkbFtraceEvent & from)367 void NetifReceiveSkbFtraceEvent::CopyFrom(const NetifReceiveSkbFtraceEvent& from) {
368 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.NetifReceiveSkbFtraceEvent)
369   if (&from == this) return;
370   Clear();
371   MergeFrom(from);
372 }
373 
IsInitialized() const374 bool NetifReceiveSkbFtraceEvent::IsInitialized() const {
375   return true;
376 }
377 
InternalSwap(NetifReceiveSkbFtraceEvent * other)378 void NetifReceiveSkbFtraceEvent::InternalSwap(NetifReceiveSkbFtraceEvent* other) {
379   using std::swap;
380   auto* lhs_arena = GetArenaForAllocation();
381   auto* rhs_arena = other->GetArenaForAllocation();
382   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
383   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
384   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
385       &_impl_.name_, lhs_arena,
386       &other->_impl_.name_, rhs_arena
387   );
388   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
389       PROTOBUF_FIELD_OFFSET(NetifReceiveSkbFtraceEvent, _impl_.len_)
390       + sizeof(NetifReceiveSkbFtraceEvent::_impl_.len_)  // NOLINT
391       - PROTOBUF_FIELD_OFFSET(NetifReceiveSkbFtraceEvent, _impl_.skbaddr_)>(
392           reinterpret_cast<char*>(&_impl_.skbaddr_),
393           reinterpret_cast<char*>(&other->_impl_.skbaddr_));
394 }
395 
GetTypeName() const396 std::string NetifReceiveSkbFtraceEvent::GetTypeName() const {
397   return "perfetto.protos.NetifReceiveSkbFtraceEvent";
398 }
399 
400 
401 // ===================================================================
402 
403 class NetDevXmitFtraceEvent::_Internal {
404  public:
405   using HasBits = decltype(std::declval<NetDevXmitFtraceEvent>()._impl_._has_bits_);
set_has_len(HasBits * has_bits)406   static void set_has_len(HasBits* has_bits) {
407     (*has_bits)[0] |= 2u;
408   }
set_has_name(HasBits * has_bits)409   static void set_has_name(HasBits* has_bits) {
410     (*has_bits)[0] |= 1u;
411   }
set_has_rc(HasBits * has_bits)412   static void set_has_rc(HasBits* has_bits) {
413     (*has_bits)[0] |= 4u;
414   }
set_has_skbaddr(HasBits * has_bits)415   static void set_has_skbaddr(HasBits* has_bits) {
416     (*has_bits)[0] |= 8u;
417   }
418 };
419 
NetDevXmitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)420 NetDevXmitFtraceEvent::NetDevXmitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
421                          bool is_message_owned)
422   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
423   SharedCtor(arena, is_message_owned);
424   // @@protoc_insertion_point(arena_constructor:perfetto.protos.NetDevXmitFtraceEvent)
425 }
NetDevXmitFtraceEvent(const NetDevXmitFtraceEvent & from)426 NetDevXmitFtraceEvent::NetDevXmitFtraceEvent(const NetDevXmitFtraceEvent& from)
427   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
428   NetDevXmitFtraceEvent* const _this = this; (void)_this;
429   new (&_impl_) Impl_{
430       decltype(_impl_._has_bits_){from._impl_._has_bits_}
431     , /*decltype(_impl_._cached_size_)*/{}
432     , decltype(_impl_.name_){}
433     , decltype(_impl_.len_){}
434     , decltype(_impl_.rc_){}
435     , decltype(_impl_.skbaddr_){}};
436 
437   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
438   _impl_.name_.InitDefault();
439   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
440     _impl_.name_.Set("", GetArenaForAllocation());
441   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
442   if (from._internal_has_name()) {
443     _this->_impl_.name_.Set(from._internal_name(),
444       _this->GetArenaForAllocation());
445   }
446   ::memcpy(&_impl_.len_, &from._impl_.len_,
447     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.skbaddr_) -
448     reinterpret_cast<char*>(&_impl_.len_)) + sizeof(_impl_.skbaddr_));
449   // @@protoc_insertion_point(copy_constructor:perfetto.protos.NetDevXmitFtraceEvent)
450 }
451 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)452 inline void NetDevXmitFtraceEvent::SharedCtor(
453     ::_pb::Arena* arena, bool is_message_owned) {
454   (void)arena;
455   (void)is_message_owned;
456   new (&_impl_) Impl_{
457       decltype(_impl_._has_bits_){}
458     , /*decltype(_impl_._cached_size_)*/{}
459     , decltype(_impl_.name_){}
460     , decltype(_impl_.len_){0u}
461     , decltype(_impl_.rc_){0}
462     , decltype(_impl_.skbaddr_){::uint64_t{0u}}
463   };
464   _impl_.name_.InitDefault();
465   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
466     _impl_.name_.Set("", GetArenaForAllocation());
467   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
468 }
469 
~NetDevXmitFtraceEvent()470 NetDevXmitFtraceEvent::~NetDevXmitFtraceEvent() {
471   // @@protoc_insertion_point(destructor:perfetto.protos.NetDevXmitFtraceEvent)
472   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
473   (void)arena;
474     return;
475   }
476   SharedDtor();
477 }
478 
SharedDtor()479 inline void NetDevXmitFtraceEvent::SharedDtor() {
480   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
481   _impl_.name_.Destroy();
482 }
483 
SetCachedSize(int size) const484 void NetDevXmitFtraceEvent::SetCachedSize(int size) const {
485   _impl_._cached_size_.Set(size);
486 }
487 
Clear()488 void NetDevXmitFtraceEvent::Clear() {
489 // @@protoc_insertion_point(message_clear_start:perfetto.protos.NetDevXmitFtraceEvent)
490   ::uint32_t cached_has_bits = 0;
491   // Prevent compiler warnings about cached_has_bits being unused
492   (void) cached_has_bits;
493 
494   cached_has_bits = _impl_._has_bits_[0];
495   if (cached_has_bits & 0x00000001u) {
496     _impl_.name_.ClearNonDefaultToEmpty();
497   }
498   if (cached_has_bits & 0x0000000eu) {
499     ::memset(&_impl_.len_, 0, static_cast<size_t>(
500         reinterpret_cast<char*>(&_impl_.skbaddr_) -
501         reinterpret_cast<char*>(&_impl_.len_)) + sizeof(_impl_.skbaddr_));
502   }
503   _impl_._has_bits_.Clear();
504   _internal_metadata_.Clear<std::string>();
505 }
506 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)507 const char* NetDevXmitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
508 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
509   _Internal::HasBits has_bits{};
510   while (!ctx->Done(&ptr)) {
511     ::uint32_t tag;
512     ptr = ::_pbi::ReadTag(ptr, &tag);
513     switch (tag >> 3) {
514       // optional uint32 len = 1;
515       case 1:
516         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
517           _Internal::set_has_len(&has_bits);
518           _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
519           CHK_(ptr);
520         } else {
521           goto handle_unusual;
522         }
523         continue;
524       // optional string name = 2;
525       case 2:
526         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
527           auto str = _internal_mutable_name();
528           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
529           CHK_(ptr);
530         } else {
531           goto handle_unusual;
532         }
533         continue;
534       // optional int32 rc = 3;
535       case 3:
536         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
537           _Internal::set_has_rc(&has_bits);
538           _impl_.rc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
539           CHK_(ptr);
540         } else {
541           goto handle_unusual;
542         }
543         continue;
544       // optional uint64 skbaddr = 4;
545       case 4:
546         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
547           _Internal::set_has_skbaddr(&has_bits);
548           _impl_.skbaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
549           CHK_(ptr);
550         } else {
551           goto handle_unusual;
552         }
553         continue;
554       default:
555         goto handle_unusual;
556     }  // switch
557   handle_unusual:
558     if ((tag == 0) || ((tag & 7) == 4)) {
559       CHK_(ptr);
560       ctx->SetLastTag(tag);
561       goto message_done;
562     }
563     ptr = UnknownFieldParse(
564         tag,
565         _internal_metadata_.mutable_unknown_fields<std::string>(),
566         ptr, ctx);
567     CHK_(ptr != nullptr);
568   }  // while
569 message_done:
570   _impl_._has_bits_.Or(has_bits);
571   return ptr;
572 failure:
573   ptr = nullptr;
574   goto message_done;
575 #undef CHK_
576 }
577 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const578 ::uint8_t* NetDevXmitFtraceEvent::_InternalSerialize(
579     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
580   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.NetDevXmitFtraceEvent)
581   ::uint32_t cached_has_bits = 0;
582   (void) cached_has_bits;
583 
584   cached_has_bits = _impl_._has_bits_[0];
585   // optional uint32 len = 1;
586   if (cached_has_bits & 0x00000002u) {
587     target = stream->EnsureSpace(target);
588     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_len(), target);
589   }
590 
591   // optional string name = 2;
592   if (cached_has_bits & 0x00000001u) {
593     target = stream->WriteStringMaybeAliased(
594         2, this->_internal_name(), target);
595   }
596 
597   // optional int32 rc = 3;
598   if (cached_has_bits & 0x00000004u) {
599     target = stream->EnsureSpace(target);
600     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_rc(), target);
601   }
602 
603   // optional uint64 skbaddr = 4;
604   if (cached_has_bits & 0x00000008u) {
605     target = stream->EnsureSpace(target);
606     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_skbaddr(), target);
607   }
608 
609   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
610     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
611         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
612   }
613   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.NetDevXmitFtraceEvent)
614   return target;
615 }
616 
ByteSizeLong() const617 size_t NetDevXmitFtraceEvent::ByteSizeLong() const {
618 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.NetDevXmitFtraceEvent)
619   size_t total_size = 0;
620 
621   ::uint32_t cached_has_bits = 0;
622   // Prevent compiler warnings about cached_has_bits being unused
623   (void) cached_has_bits;
624 
625   cached_has_bits = _impl_._has_bits_[0];
626   if (cached_has_bits & 0x0000000fu) {
627     // optional string name = 2;
628     if (cached_has_bits & 0x00000001u) {
629       total_size += 1 +
630         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
631           this->_internal_name());
632     }
633 
634     // optional uint32 len = 1;
635     if (cached_has_bits & 0x00000002u) {
636       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
637     }
638 
639     // optional int32 rc = 3;
640     if (cached_has_bits & 0x00000004u) {
641       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_rc());
642     }
643 
644     // optional uint64 skbaddr = 4;
645     if (cached_has_bits & 0x00000008u) {
646       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_skbaddr());
647     }
648 
649   }
650   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
651     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
652   }
653   int cached_size = ::_pbi::ToCachedSize(total_size);
654   SetCachedSize(cached_size);
655   return total_size;
656 }
657 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)658 void NetDevXmitFtraceEvent::CheckTypeAndMergeFrom(
659     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
660   MergeFrom(*::_pbi::DownCast<const NetDevXmitFtraceEvent*>(
661       &from));
662 }
663 
MergeFrom(const NetDevXmitFtraceEvent & from)664 void NetDevXmitFtraceEvent::MergeFrom(const NetDevXmitFtraceEvent& from) {
665   NetDevXmitFtraceEvent* const _this = this;
666   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.NetDevXmitFtraceEvent)
667   GOOGLE_DCHECK_NE(&from, _this);
668   ::uint32_t cached_has_bits = 0;
669   (void) cached_has_bits;
670 
671   cached_has_bits = from._impl_._has_bits_[0];
672   if (cached_has_bits & 0x0000000fu) {
673     if (cached_has_bits & 0x00000001u) {
674       _this->_internal_set_name(from._internal_name());
675     }
676     if (cached_has_bits & 0x00000002u) {
677       _this->_impl_.len_ = from._impl_.len_;
678     }
679     if (cached_has_bits & 0x00000004u) {
680       _this->_impl_.rc_ = from._impl_.rc_;
681     }
682     if (cached_has_bits & 0x00000008u) {
683       _this->_impl_.skbaddr_ = from._impl_.skbaddr_;
684     }
685     _this->_impl_._has_bits_[0] |= cached_has_bits;
686   }
687   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
688 }
689 
CopyFrom(const NetDevXmitFtraceEvent & from)690 void NetDevXmitFtraceEvent::CopyFrom(const NetDevXmitFtraceEvent& from) {
691 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.NetDevXmitFtraceEvent)
692   if (&from == this) return;
693   Clear();
694   MergeFrom(from);
695 }
696 
IsInitialized() const697 bool NetDevXmitFtraceEvent::IsInitialized() const {
698   return true;
699 }
700 
InternalSwap(NetDevXmitFtraceEvent * other)701 void NetDevXmitFtraceEvent::InternalSwap(NetDevXmitFtraceEvent* other) {
702   using std::swap;
703   auto* lhs_arena = GetArenaForAllocation();
704   auto* rhs_arena = other->GetArenaForAllocation();
705   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
706   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
707   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
708       &_impl_.name_, lhs_arena,
709       &other->_impl_.name_, rhs_arena
710   );
711   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
712       PROTOBUF_FIELD_OFFSET(NetDevXmitFtraceEvent, _impl_.skbaddr_)
713       + sizeof(NetDevXmitFtraceEvent::_impl_.skbaddr_)  // NOLINT
714       - PROTOBUF_FIELD_OFFSET(NetDevXmitFtraceEvent, _impl_.len_)>(
715           reinterpret_cast<char*>(&_impl_.len_),
716           reinterpret_cast<char*>(&other->_impl_.len_));
717 }
718 
GetTypeName() const719 std::string NetDevXmitFtraceEvent::GetTypeName() const {
720   return "perfetto.protos.NetDevXmitFtraceEvent";
721 }
722 
723 
724 // ===================================================================
725 
726 class NapiGroReceiveEntryFtraceEvent::_Internal {
727  public:
728   using HasBits = decltype(std::declval<NapiGroReceiveEntryFtraceEvent>()._impl_._has_bits_);
set_has_data_len(HasBits * has_bits)729   static void set_has_data_len(HasBits* has_bits) {
730     (*has_bits)[0] |= 2u;
731   }
set_has_gso_size(HasBits * has_bits)732   static void set_has_gso_size(HasBits* has_bits) {
733     (*has_bits)[0] |= 4u;
734   }
set_has_gso_type(HasBits * has_bits)735   static void set_has_gso_type(HasBits* has_bits) {
736     (*has_bits)[0] |= 8u;
737   }
set_has_hash(HasBits * has_bits)738   static void set_has_hash(HasBits* has_bits) {
739     (*has_bits)[0] |= 16u;
740   }
set_has_ip_summed(HasBits * has_bits)741   static void set_has_ip_summed(HasBits* has_bits) {
742     (*has_bits)[0] |= 32u;
743   }
set_has_l4_hash(HasBits * has_bits)744   static void set_has_l4_hash(HasBits* has_bits) {
745     (*has_bits)[0] |= 64u;
746   }
set_has_len(HasBits * has_bits)747   static void set_has_len(HasBits* has_bits) {
748     (*has_bits)[0] |= 128u;
749   }
set_has_mac_header(HasBits * has_bits)750   static void set_has_mac_header(HasBits* has_bits) {
751     (*has_bits)[0] |= 256u;
752   }
set_has_mac_header_valid(HasBits * has_bits)753   static void set_has_mac_header_valid(HasBits* has_bits) {
754     (*has_bits)[0] |= 512u;
755   }
set_has_name(HasBits * has_bits)756   static void set_has_name(HasBits* has_bits) {
757     (*has_bits)[0] |= 1u;
758   }
set_has_napi_id(HasBits * has_bits)759   static void set_has_napi_id(HasBits* has_bits) {
760     (*has_bits)[0] |= 1024u;
761   }
set_has_nr_frags(HasBits * has_bits)762   static void set_has_nr_frags(HasBits* has_bits) {
763     (*has_bits)[0] |= 2048u;
764   }
set_has_protocol(HasBits * has_bits)765   static void set_has_protocol(HasBits* has_bits) {
766     (*has_bits)[0] |= 4096u;
767   }
set_has_queue_mapping(HasBits * has_bits)768   static void set_has_queue_mapping(HasBits* has_bits) {
769     (*has_bits)[0] |= 16384u;
770   }
set_has_skbaddr(HasBits * has_bits)771   static void set_has_skbaddr(HasBits* has_bits) {
772     (*has_bits)[0] |= 8192u;
773   }
set_has_truesize(HasBits * has_bits)774   static void set_has_truesize(HasBits* has_bits) {
775     (*has_bits)[0] |= 32768u;
776   }
set_has_vlan_proto(HasBits * has_bits)777   static void set_has_vlan_proto(HasBits* has_bits) {
778     (*has_bits)[0] |= 65536u;
779   }
set_has_vlan_tagged(HasBits * has_bits)780   static void set_has_vlan_tagged(HasBits* has_bits) {
781     (*has_bits)[0] |= 131072u;
782   }
set_has_vlan_tci(HasBits * has_bits)783   static void set_has_vlan_tci(HasBits* has_bits) {
784     (*has_bits)[0] |= 262144u;
785   }
786 };
787 
NapiGroReceiveEntryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)788 NapiGroReceiveEntryFtraceEvent::NapiGroReceiveEntryFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
789                          bool is_message_owned)
790   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
791   SharedCtor(arena, is_message_owned);
792   // @@protoc_insertion_point(arena_constructor:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
793 }
NapiGroReceiveEntryFtraceEvent(const NapiGroReceiveEntryFtraceEvent & from)794 NapiGroReceiveEntryFtraceEvent::NapiGroReceiveEntryFtraceEvent(const NapiGroReceiveEntryFtraceEvent& from)
795   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
796   NapiGroReceiveEntryFtraceEvent* const _this = this; (void)_this;
797   new (&_impl_) Impl_{
798       decltype(_impl_._has_bits_){from._impl_._has_bits_}
799     , /*decltype(_impl_._cached_size_)*/{}
800     , decltype(_impl_.name_){}
801     , decltype(_impl_.data_len_){}
802     , decltype(_impl_.gso_size_){}
803     , decltype(_impl_.gso_type_){}
804     , decltype(_impl_.hash_){}
805     , decltype(_impl_.ip_summed_){}
806     , decltype(_impl_.l4_hash_){}
807     , decltype(_impl_.len_){}
808     , decltype(_impl_.mac_header_){}
809     , decltype(_impl_.mac_header_valid_){}
810     , decltype(_impl_.napi_id_){}
811     , decltype(_impl_.nr_frags_){}
812     , decltype(_impl_.protocol_){}
813     , decltype(_impl_.skbaddr_){}
814     , decltype(_impl_.queue_mapping_){}
815     , decltype(_impl_.truesize_){}
816     , decltype(_impl_.vlan_proto_){}
817     , decltype(_impl_.vlan_tagged_){}
818     , decltype(_impl_.vlan_tci_){}};
819 
820   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
821   _impl_.name_.InitDefault();
822   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
823     _impl_.name_.Set("", GetArenaForAllocation());
824   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
825   if (from._internal_has_name()) {
826     _this->_impl_.name_.Set(from._internal_name(),
827       _this->GetArenaForAllocation());
828   }
829   ::memcpy(&_impl_.data_len_, &from._impl_.data_len_,
830     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.vlan_tci_) -
831     reinterpret_cast<char*>(&_impl_.data_len_)) + sizeof(_impl_.vlan_tci_));
832   // @@protoc_insertion_point(copy_constructor:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
833 }
834 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)835 inline void NapiGroReceiveEntryFtraceEvent::SharedCtor(
836     ::_pb::Arena* arena, bool is_message_owned) {
837   (void)arena;
838   (void)is_message_owned;
839   new (&_impl_) Impl_{
840       decltype(_impl_._has_bits_){}
841     , /*decltype(_impl_._cached_size_)*/{}
842     , decltype(_impl_.name_){}
843     , decltype(_impl_.data_len_){0u}
844     , decltype(_impl_.gso_size_){0u}
845     , decltype(_impl_.gso_type_){0u}
846     , decltype(_impl_.hash_){0u}
847     , decltype(_impl_.ip_summed_){0u}
848     , decltype(_impl_.l4_hash_){0u}
849     , decltype(_impl_.len_){0u}
850     , decltype(_impl_.mac_header_){0}
851     , decltype(_impl_.mac_header_valid_){0u}
852     , decltype(_impl_.napi_id_){0u}
853     , decltype(_impl_.nr_frags_){0u}
854     , decltype(_impl_.protocol_){0u}
855     , decltype(_impl_.skbaddr_){::uint64_t{0u}}
856     , decltype(_impl_.queue_mapping_){0u}
857     , decltype(_impl_.truesize_){0u}
858     , decltype(_impl_.vlan_proto_){0u}
859     , decltype(_impl_.vlan_tagged_){0u}
860     , decltype(_impl_.vlan_tci_){0u}
861   };
862   _impl_.name_.InitDefault();
863   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
864     _impl_.name_.Set("", GetArenaForAllocation());
865   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
866 }
867 
~NapiGroReceiveEntryFtraceEvent()868 NapiGroReceiveEntryFtraceEvent::~NapiGroReceiveEntryFtraceEvent() {
869   // @@protoc_insertion_point(destructor:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
870   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
871   (void)arena;
872     return;
873   }
874   SharedDtor();
875 }
876 
SharedDtor()877 inline void NapiGroReceiveEntryFtraceEvent::SharedDtor() {
878   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
879   _impl_.name_.Destroy();
880 }
881 
SetCachedSize(int size) const882 void NapiGroReceiveEntryFtraceEvent::SetCachedSize(int size) const {
883   _impl_._cached_size_.Set(size);
884 }
885 
Clear()886 void NapiGroReceiveEntryFtraceEvent::Clear() {
887 // @@protoc_insertion_point(message_clear_start:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
888   ::uint32_t cached_has_bits = 0;
889   // Prevent compiler warnings about cached_has_bits being unused
890   (void) cached_has_bits;
891 
892   cached_has_bits = _impl_._has_bits_[0];
893   if (cached_has_bits & 0x00000001u) {
894     _impl_.name_.ClearNonDefaultToEmpty();
895   }
896   if (cached_has_bits & 0x000000feu) {
897     ::memset(&_impl_.data_len_, 0, static_cast<size_t>(
898         reinterpret_cast<char*>(&_impl_.len_) -
899         reinterpret_cast<char*>(&_impl_.data_len_)) + sizeof(_impl_.len_));
900   }
901   if (cached_has_bits & 0x0000ff00u) {
902     ::memset(&_impl_.mac_header_, 0, static_cast<size_t>(
903         reinterpret_cast<char*>(&_impl_.truesize_) -
904         reinterpret_cast<char*>(&_impl_.mac_header_)) + sizeof(_impl_.truesize_));
905   }
906   if (cached_has_bits & 0x00070000u) {
907     ::memset(&_impl_.vlan_proto_, 0, static_cast<size_t>(
908         reinterpret_cast<char*>(&_impl_.vlan_tci_) -
909         reinterpret_cast<char*>(&_impl_.vlan_proto_)) + sizeof(_impl_.vlan_tci_));
910   }
911   _impl_._has_bits_.Clear();
912   _internal_metadata_.Clear<std::string>();
913 }
914 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)915 const char* NapiGroReceiveEntryFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
916 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
917   _Internal::HasBits has_bits{};
918   while (!ctx->Done(&ptr)) {
919     ::uint32_t tag;
920     ptr = ::_pbi::ReadTag(ptr, &tag);
921     switch (tag >> 3) {
922       // optional uint32 data_len = 1;
923       case 1:
924         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
925           _Internal::set_has_data_len(&has_bits);
926           _impl_.data_len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
927           CHK_(ptr);
928         } else {
929           goto handle_unusual;
930         }
931         continue;
932       // optional uint32 gso_size = 2;
933       case 2:
934         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
935           _Internal::set_has_gso_size(&has_bits);
936           _impl_.gso_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
937           CHK_(ptr);
938         } else {
939           goto handle_unusual;
940         }
941         continue;
942       // optional uint32 gso_type = 3;
943       case 3:
944         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
945           _Internal::set_has_gso_type(&has_bits);
946           _impl_.gso_type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
947           CHK_(ptr);
948         } else {
949           goto handle_unusual;
950         }
951         continue;
952       // optional uint32 hash = 4;
953       case 4:
954         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
955           _Internal::set_has_hash(&has_bits);
956           _impl_.hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
957           CHK_(ptr);
958         } else {
959           goto handle_unusual;
960         }
961         continue;
962       // optional uint32 ip_summed = 5;
963       case 5:
964         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
965           _Internal::set_has_ip_summed(&has_bits);
966           _impl_.ip_summed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
967           CHK_(ptr);
968         } else {
969           goto handle_unusual;
970         }
971         continue;
972       // optional uint32 l4_hash = 6;
973       case 6:
974         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
975           _Internal::set_has_l4_hash(&has_bits);
976           _impl_.l4_hash_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
977           CHK_(ptr);
978         } else {
979           goto handle_unusual;
980         }
981         continue;
982       // optional uint32 len = 7;
983       case 7:
984         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
985           _Internal::set_has_len(&has_bits);
986           _impl_.len_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
987           CHK_(ptr);
988         } else {
989           goto handle_unusual;
990         }
991         continue;
992       // optional int32 mac_header = 8;
993       case 8:
994         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
995           _Internal::set_has_mac_header(&has_bits);
996           _impl_.mac_header_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
997           CHK_(ptr);
998         } else {
999           goto handle_unusual;
1000         }
1001         continue;
1002       // optional uint32 mac_header_valid = 9;
1003       case 9:
1004         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1005           _Internal::set_has_mac_header_valid(&has_bits);
1006           _impl_.mac_header_valid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1007           CHK_(ptr);
1008         } else {
1009           goto handle_unusual;
1010         }
1011         continue;
1012       // optional string name = 10;
1013       case 10:
1014         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
1015           auto str = _internal_mutable_name();
1016           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1017           CHK_(ptr);
1018         } else {
1019           goto handle_unusual;
1020         }
1021         continue;
1022       // optional uint32 napi_id = 11;
1023       case 11:
1024         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1025           _Internal::set_has_napi_id(&has_bits);
1026           _impl_.napi_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1027           CHK_(ptr);
1028         } else {
1029           goto handle_unusual;
1030         }
1031         continue;
1032       // optional uint32 nr_frags = 12;
1033       case 12:
1034         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
1035           _Internal::set_has_nr_frags(&has_bits);
1036           _impl_.nr_frags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1037           CHK_(ptr);
1038         } else {
1039           goto handle_unusual;
1040         }
1041         continue;
1042       // optional uint32 protocol = 13;
1043       case 13:
1044         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
1045           _Internal::set_has_protocol(&has_bits);
1046           _impl_.protocol_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1047           CHK_(ptr);
1048         } else {
1049           goto handle_unusual;
1050         }
1051         continue;
1052       // optional uint32 queue_mapping = 14;
1053       case 14:
1054         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
1055           _Internal::set_has_queue_mapping(&has_bits);
1056           _impl_.queue_mapping_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1057           CHK_(ptr);
1058         } else {
1059           goto handle_unusual;
1060         }
1061         continue;
1062       // optional uint64 skbaddr = 15;
1063       case 15:
1064         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
1065           _Internal::set_has_skbaddr(&has_bits);
1066           _impl_.skbaddr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1067           CHK_(ptr);
1068         } else {
1069           goto handle_unusual;
1070         }
1071         continue;
1072       // optional uint32 truesize = 16;
1073       case 16:
1074         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
1075           _Internal::set_has_truesize(&has_bits);
1076           _impl_.truesize_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1077           CHK_(ptr);
1078         } else {
1079           goto handle_unusual;
1080         }
1081         continue;
1082       // optional uint32 vlan_proto = 17;
1083       case 17:
1084         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 136)) {
1085           _Internal::set_has_vlan_proto(&has_bits);
1086           _impl_.vlan_proto_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1087           CHK_(ptr);
1088         } else {
1089           goto handle_unusual;
1090         }
1091         continue;
1092       // optional uint32 vlan_tagged = 18;
1093       case 18:
1094         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 144)) {
1095           _Internal::set_has_vlan_tagged(&has_bits);
1096           _impl_.vlan_tagged_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1097           CHK_(ptr);
1098         } else {
1099           goto handle_unusual;
1100         }
1101         continue;
1102       // optional uint32 vlan_tci = 19;
1103       case 19:
1104         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 152)) {
1105           _Internal::set_has_vlan_tci(&has_bits);
1106           _impl_.vlan_tci_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1107           CHK_(ptr);
1108         } else {
1109           goto handle_unusual;
1110         }
1111         continue;
1112       default:
1113         goto handle_unusual;
1114     }  // switch
1115   handle_unusual:
1116     if ((tag == 0) || ((tag & 7) == 4)) {
1117       CHK_(ptr);
1118       ctx->SetLastTag(tag);
1119       goto message_done;
1120     }
1121     ptr = UnknownFieldParse(
1122         tag,
1123         _internal_metadata_.mutable_unknown_fields<std::string>(),
1124         ptr, ctx);
1125     CHK_(ptr != nullptr);
1126   }  // while
1127 message_done:
1128   _impl_._has_bits_.Or(has_bits);
1129   return ptr;
1130 failure:
1131   ptr = nullptr;
1132   goto message_done;
1133 #undef CHK_
1134 }
1135 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1136 ::uint8_t* NapiGroReceiveEntryFtraceEvent::_InternalSerialize(
1137     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1138   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
1139   ::uint32_t cached_has_bits = 0;
1140   (void) cached_has_bits;
1141 
1142   cached_has_bits = _impl_._has_bits_[0];
1143   // optional uint32 data_len = 1;
1144   if (cached_has_bits & 0x00000002u) {
1145     target = stream->EnsureSpace(target);
1146     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_data_len(), target);
1147   }
1148 
1149   // optional uint32 gso_size = 2;
1150   if (cached_has_bits & 0x00000004u) {
1151     target = stream->EnsureSpace(target);
1152     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_gso_size(), target);
1153   }
1154 
1155   // optional uint32 gso_type = 3;
1156   if (cached_has_bits & 0x00000008u) {
1157     target = stream->EnsureSpace(target);
1158     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_gso_type(), target);
1159   }
1160 
1161   // optional uint32 hash = 4;
1162   if (cached_has_bits & 0x00000010u) {
1163     target = stream->EnsureSpace(target);
1164     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_hash(), target);
1165   }
1166 
1167   // optional uint32 ip_summed = 5;
1168   if (cached_has_bits & 0x00000020u) {
1169     target = stream->EnsureSpace(target);
1170     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_ip_summed(), target);
1171   }
1172 
1173   // optional uint32 l4_hash = 6;
1174   if (cached_has_bits & 0x00000040u) {
1175     target = stream->EnsureSpace(target);
1176     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_l4_hash(), target);
1177   }
1178 
1179   // optional uint32 len = 7;
1180   if (cached_has_bits & 0x00000080u) {
1181     target = stream->EnsureSpace(target);
1182     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_len(), target);
1183   }
1184 
1185   // optional int32 mac_header = 8;
1186   if (cached_has_bits & 0x00000100u) {
1187     target = stream->EnsureSpace(target);
1188     target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_mac_header(), target);
1189   }
1190 
1191   // optional uint32 mac_header_valid = 9;
1192   if (cached_has_bits & 0x00000200u) {
1193     target = stream->EnsureSpace(target);
1194     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_mac_header_valid(), target);
1195   }
1196 
1197   // optional string name = 10;
1198   if (cached_has_bits & 0x00000001u) {
1199     target = stream->WriteStringMaybeAliased(
1200         10, this->_internal_name(), target);
1201   }
1202 
1203   // optional uint32 napi_id = 11;
1204   if (cached_has_bits & 0x00000400u) {
1205     target = stream->EnsureSpace(target);
1206     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_napi_id(), target);
1207   }
1208 
1209   // optional uint32 nr_frags = 12;
1210   if (cached_has_bits & 0x00000800u) {
1211     target = stream->EnsureSpace(target);
1212     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(12, this->_internal_nr_frags(), target);
1213   }
1214 
1215   // optional uint32 protocol = 13;
1216   if (cached_has_bits & 0x00001000u) {
1217     target = stream->EnsureSpace(target);
1218     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(13, this->_internal_protocol(), target);
1219   }
1220 
1221   // optional uint32 queue_mapping = 14;
1222   if (cached_has_bits & 0x00004000u) {
1223     target = stream->EnsureSpace(target);
1224     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(14, this->_internal_queue_mapping(), target);
1225   }
1226 
1227   // optional uint64 skbaddr = 15;
1228   if (cached_has_bits & 0x00002000u) {
1229     target = stream->EnsureSpace(target);
1230     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(15, this->_internal_skbaddr(), target);
1231   }
1232 
1233   // optional uint32 truesize = 16;
1234   if (cached_has_bits & 0x00008000u) {
1235     target = stream->EnsureSpace(target);
1236     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_truesize(), target);
1237   }
1238 
1239   // optional uint32 vlan_proto = 17;
1240   if (cached_has_bits & 0x00010000u) {
1241     target = stream->EnsureSpace(target);
1242     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(17, this->_internal_vlan_proto(), target);
1243   }
1244 
1245   // optional uint32 vlan_tagged = 18;
1246   if (cached_has_bits & 0x00020000u) {
1247     target = stream->EnsureSpace(target);
1248     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(18, this->_internal_vlan_tagged(), target);
1249   }
1250 
1251   // optional uint32 vlan_tci = 19;
1252   if (cached_has_bits & 0x00040000u) {
1253     target = stream->EnsureSpace(target);
1254     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(19, this->_internal_vlan_tci(), target);
1255   }
1256 
1257   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1258     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1259         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1260   }
1261   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
1262   return target;
1263 }
1264 
ByteSizeLong() const1265 size_t NapiGroReceiveEntryFtraceEvent::ByteSizeLong() const {
1266 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
1267   size_t total_size = 0;
1268 
1269   ::uint32_t cached_has_bits = 0;
1270   // Prevent compiler warnings about cached_has_bits being unused
1271   (void) cached_has_bits;
1272 
1273   cached_has_bits = _impl_._has_bits_[0];
1274   if (cached_has_bits & 0x000000ffu) {
1275     // optional string name = 10;
1276     if (cached_has_bits & 0x00000001u) {
1277       total_size += 1 +
1278         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1279           this->_internal_name());
1280     }
1281 
1282     // optional uint32 data_len = 1;
1283     if (cached_has_bits & 0x00000002u) {
1284       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_data_len());
1285     }
1286 
1287     // optional uint32 gso_size = 2;
1288     if (cached_has_bits & 0x00000004u) {
1289       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gso_size());
1290     }
1291 
1292     // optional uint32 gso_type = 3;
1293     if (cached_has_bits & 0x00000008u) {
1294       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gso_type());
1295     }
1296 
1297     // optional uint32 hash = 4;
1298     if (cached_has_bits & 0x00000010u) {
1299       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_hash());
1300     }
1301 
1302     // optional uint32 ip_summed = 5;
1303     if (cached_has_bits & 0x00000020u) {
1304       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ip_summed());
1305     }
1306 
1307     // optional uint32 l4_hash = 6;
1308     if (cached_has_bits & 0x00000040u) {
1309       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_l4_hash());
1310     }
1311 
1312     // optional uint32 len = 7;
1313     if (cached_has_bits & 0x00000080u) {
1314       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_len());
1315     }
1316 
1317   }
1318   if (cached_has_bits & 0x0000ff00u) {
1319     // optional int32 mac_header = 8;
1320     if (cached_has_bits & 0x00000100u) {
1321       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_mac_header());
1322     }
1323 
1324     // optional uint32 mac_header_valid = 9;
1325     if (cached_has_bits & 0x00000200u) {
1326       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mac_header_valid());
1327     }
1328 
1329     // optional uint32 napi_id = 11;
1330     if (cached_has_bits & 0x00000400u) {
1331       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_napi_id());
1332     }
1333 
1334     // optional uint32 nr_frags = 12;
1335     if (cached_has_bits & 0x00000800u) {
1336       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_frags());
1337     }
1338 
1339     // optional uint32 protocol = 13;
1340     if (cached_has_bits & 0x00001000u) {
1341       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_protocol());
1342     }
1343 
1344     // optional uint64 skbaddr = 15;
1345     if (cached_has_bits & 0x00002000u) {
1346       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_skbaddr());
1347     }
1348 
1349     // optional uint32 queue_mapping = 14;
1350     if (cached_has_bits & 0x00004000u) {
1351       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_queue_mapping());
1352     }
1353 
1354     // optional uint32 truesize = 16;
1355     if (cached_has_bits & 0x00008000u) {
1356       total_size += 2 +
1357         ::_pbi::WireFormatLite::UInt32Size(
1358           this->_internal_truesize());
1359     }
1360 
1361   }
1362   if (cached_has_bits & 0x00070000u) {
1363     // optional uint32 vlan_proto = 17;
1364     if (cached_has_bits & 0x00010000u) {
1365       total_size += 2 +
1366         ::_pbi::WireFormatLite::UInt32Size(
1367           this->_internal_vlan_proto());
1368     }
1369 
1370     // optional uint32 vlan_tagged = 18;
1371     if (cached_has_bits & 0x00020000u) {
1372       total_size += 2 +
1373         ::_pbi::WireFormatLite::UInt32Size(
1374           this->_internal_vlan_tagged());
1375     }
1376 
1377     // optional uint32 vlan_tci = 19;
1378     if (cached_has_bits & 0x00040000u) {
1379       total_size += 2 +
1380         ::_pbi::WireFormatLite::UInt32Size(
1381           this->_internal_vlan_tci());
1382     }
1383 
1384   }
1385   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1386     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1387   }
1388   int cached_size = ::_pbi::ToCachedSize(total_size);
1389   SetCachedSize(cached_size);
1390   return total_size;
1391 }
1392 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1393 void NapiGroReceiveEntryFtraceEvent::CheckTypeAndMergeFrom(
1394     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1395   MergeFrom(*::_pbi::DownCast<const NapiGroReceiveEntryFtraceEvent*>(
1396       &from));
1397 }
1398 
MergeFrom(const NapiGroReceiveEntryFtraceEvent & from)1399 void NapiGroReceiveEntryFtraceEvent::MergeFrom(const NapiGroReceiveEntryFtraceEvent& from) {
1400   NapiGroReceiveEntryFtraceEvent* const _this = this;
1401   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
1402   GOOGLE_DCHECK_NE(&from, _this);
1403   ::uint32_t cached_has_bits = 0;
1404   (void) cached_has_bits;
1405 
1406   cached_has_bits = from._impl_._has_bits_[0];
1407   if (cached_has_bits & 0x000000ffu) {
1408     if (cached_has_bits & 0x00000001u) {
1409       _this->_internal_set_name(from._internal_name());
1410     }
1411     if (cached_has_bits & 0x00000002u) {
1412       _this->_impl_.data_len_ = from._impl_.data_len_;
1413     }
1414     if (cached_has_bits & 0x00000004u) {
1415       _this->_impl_.gso_size_ = from._impl_.gso_size_;
1416     }
1417     if (cached_has_bits & 0x00000008u) {
1418       _this->_impl_.gso_type_ = from._impl_.gso_type_;
1419     }
1420     if (cached_has_bits & 0x00000010u) {
1421       _this->_impl_.hash_ = from._impl_.hash_;
1422     }
1423     if (cached_has_bits & 0x00000020u) {
1424       _this->_impl_.ip_summed_ = from._impl_.ip_summed_;
1425     }
1426     if (cached_has_bits & 0x00000040u) {
1427       _this->_impl_.l4_hash_ = from._impl_.l4_hash_;
1428     }
1429     if (cached_has_bits & 0x00000080u) {
1430       _this->_impl_.len_ = from._impl_.len_;
1431     }
1432     _this->_impl_._has_bits_[0] |= cached_has_bits;
1433   }
1434   if (cached_has_bits & 0x0000ff00u) {
1435     if (cached_has_bits & 0x00000100u) {
1436       _this->_impl_.mac_header_ = from._impl_.mac_header_;
1437     }
1438     if (cached_has_bits & 0x00000200u) {
1439       _this->_impl_.mac_header_valid_ = from._impl_.mac_header_valid_;
1440     }
1441     if (cached_has_bits & 0x00000400u) {
1442       _this->_impl_.napi_id_ = from._impl_.napi_id_;
1443     }
1444     if (cached_has_bits & 0x00000800u) {
1445       _this->_impl_.nr_frags_ = from._impl_.nr_frags_;
1446     }
1447     if (cached_has_bits & 0x00001000u) {
1448       _this->_impl_.protocol_ = from._impl_.protocol_;
1449     }
1450     if (cached_has_bits & 0x00002000u) {
1451       _this->_impl_.skbaddr_ = from._impl_.skbaddr_;
1452     }
1453     if (cached_has_bits & 0x00004000u) {
1454       _this->_impl_.queue_mapping_ = from._impl_.queue_mapping_;
1455     }
1456     if (cached_has_bits & 0x00008000u) {
1457       _this->_impl_.truesize_ = from._impl_.truesize_;
1458     }
1459     _this->_impl_._has_bits_[0] |= cached_has_bits;
1460   }
1461   if (cached_has_bits & 0x00070000u) {
1462     if (cached_has_bits & 0x00010000u) {
1463       _this->_impl_.vlan_proto_ = from._impl_.vlan_proto_;
1464     }
1465     if (cached_has_bits & 0x00020000u) {
1466       _this->_impl_.vlan_tagged_ = from._impl_.vlan_tagged_;
1467     }
1468     if (cached_has_bits & 0x00040000u) {
1469       _this->_impl_.vlan_tci_ = from._impl_.vlan_tci_;
1470     }
1471     _this->_impl_._has_bits_[0] |= cached_has_bits;
1472   }
1473   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1474 }
1475 
CopyFrom(const NapiGroReceiveEntryFtraceEvent & from)1476 void NapiGroReceiveEntryFtraceEvent::CopyFrom(const NapiGroReceiveEntryFtraceEvent& from) {
1477 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.NapiGroReceiveEntryFtraceEvent)
1478   if (&from == this) return;
1479   Clear();
1480   MergeFrom(from);
1481 }
1482 
IsInitialized() const1483 bool NapiGroReceiveEntryFtraceEvent::IsInitialized() const {
1484   return true;
1485 }
1486 
InternalSwap(NapiGroReceiveEntryFtraceEvent * other)1487 void NapiGroReceiveEntryFtraceEvent::InternalSwap(NapiGroReceiveEntryFtraceEvent* other) {
1488   using std::swap;
1489   auto* lhs_arena = GetArenaForAllocation();
1490   auto* rhs_arena = other->GetArenaForAllocation();
1491   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1492   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1493   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1494       &_impl_.name_, lhs_arena,
1495       &other->_impl_.name_, rhs_arena
1496   );
1497   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1498       PROTOBUF_FIELD_OFFSET(NapiGroReceiveEntryFtraceEvent, _impl_.vlan_tci_)
1499       + sizeof(NapiGroReceiveEntryFtraceEvent::_impl_.vlan_tci_)  // NOLINT
1500       - PROTOBUF_FIELD_OFFSET(NapiGroReceiveEntryFtraceEvent, _impl_.data_len_)>(
1501           reinterpret_cast<char*>(&_impl_.data_len_),
1502           reinterpret_cast<char*>(&other->_impl_.data_len_));
1503 }
1504 
GetTypeName() const1505 std::string NapiGroReceiveEntryFtraceEvent::GetTypeName() const {
1506   return "perfetto.protos.NapiGroReceiveEntryFtraceEvent";
1507 }
1508 
1509 
1510 // ===================================================================
1511 
1512 class NapiGroReceiveExitFtraceEvent::_Internal {
1513  public:
1514   using HasBits = decltype(std::declval<NapiGroReceiveExitFtraceEvent>()._impl_._has_bits_);
set_has_ret(HasBits * has_bits)1515   static void set_has_ret(HasBits* has_bits) {
1516     (*has_bits)[0] |= 1u;
1517   }
1518 };
1519 
NapiGroReceiveExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1520 NapiGroReceiveExitFtraceEvent::NapiGroReceiveExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1521                          bool is_message_owned)
1522   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1523   SharedCtor(arena, is_message_owned);
1524   // @@protoc_insertion_point(arena_constructor:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1525 }
NapiGroReceiveExitFtraceEvent(const NapiGroReceiveExitFtraceEvent & from)1526 NapiGroReceiveExitFtraceEvent::NapiGroReceiveExitFtraceEvent(const NapiGroReceiveExitFtraceEvent& from)
1527   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1528   NapiGroReceiveExitFtraceEvent* const _this = this; (void)_this;
1529   new (&_impl_) Impl_{
1530       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1531     , /*decltype(_impl_._cached_size_)*/{}
1532     , decltype(_impl_.ret_){}};
1533 
1534   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1535   _this->_impl_.ret_ = from._impl_.ret_;
1536   // @@protoc_insertion_point(copy_constructor:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1537 }
1538 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1539 inline void NapiGroReceiveExitFtraceEvent::SharedCtor(
1540     ::_pb::Arena* arena, bool is_message_owned) {
1541   (void)arena;
1542   (void)is_message_owned;
1543   new (&_impl_) Impl_{
1544       decltype(_impl_._has_bits_){}
1545     , /*decltype(_impl_._cached_size_)*/{}
1546     , decltype(_impl_.ret_){0}
1547   };
1548 }
1549 
~NapiGroReceiveExitFtraceEvent()1550 NapiGroReceiveExitFtraceEvent::~NapiGroReceiveExitFtraceEvent() {
1551   // @@protoc_insertion_point(destructor:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1552   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1553   (void)arena;
1554     return;
1555   }
1556   SharedDtor();
1557 }
1558 
SharedDtor()1559 inline void NapiGroReceiveExitFtraceEvent::SharedDtor() {
1560   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1561 }
1562 
SetCachedSize(int size) const1563 void NapiGroReceiveExitFtraceEvent::SetCachedSize(int size) const {
1564   _impl_._cached_size_.Set(size);
1565 }
1566 
Clear()1567 void NapiGroReceiveExitFtraceEvent::Clear() {
1568 // @@protoc_insertion_point(message_clear_start:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1569   ::uint32_t cached_has_bits = 0;
1570   // Prevent compiler warnings about cached_has_bits being unused
1571   (void) cached_has_bits;
1572 
1573   _impl_.ret_ = 0;
1574   _impl_._has_bits_.Clear();
1575   _internal_metadata_.Clear<std::string>();
1576 }
1577 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1578 const char* NapiGroReceiveExitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1579 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1580   _Internal::HasBits has_bits{};
1581   while (!ctx->Done(&ptr)) {
1582     ::uint32_t tag;
1583     ptr = ::_pbi::ReadTag(ptr, &tag);
1584     switch (tag >> 3) {
1585       // optional int32 ret = 1;
1586       case 1:
1587         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1588           _Internal::set_has_ret(&has_bits);
1589           _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1590           CHK_(ptr);
1591         } else {
1592           goto handle_unusual;
1593         }
1594         continue;
1595       default:
1596         goto handle_unusual;
1597     }  // switch
1598   handle_unusual:
1599     if ((tag == 0) || ((tag & 7) == 4)) {
1600       CHK_(ptr);
1601       ctx->SetLastTag(tag);
1602       goto message_done;
1603     }
1604     ptr = UnknownFieldParse(
1605         tag,
1606         _internal_metadata_.mutable_unknown_fields<std::string>(),
1607         ptr, ctx);
1608     CHK_(ptr != nullptr);
1609   }  // while
1610 message_done:
1611   _impl_._has_bits_.Or(has_bits);
1612   return ptr;
1613 failure:
1614   ptr = nullptr;
1615   goto message_done;
1616 #undef CHK_
1617 }
1618 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1619 ::uint8_t* NapiGroReceiveExitFtraceEvent::_InternalSerialize(
1620     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1621   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1622   ::uint32_t cached_has_bits = 0;
1623   (void) cached_has_bits;
1624 
1625   cached_has_bits = _impl_._has_bits_[0];
1626   // optional int32 ret = 1;
1627   if (cached_has_bits & 0x00000001u) {
1628     target = stream->EnsureSpace(target);
1629     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_ret(), target);
1630   }
1631 
1632   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1633     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1634         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1635   }
1636   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1637   return target;
1638 }
1639 
ByteSizeLong() const1640 size_t NapiGroReceiveExitFtraceEvent::ByteSizeLong() const {
1641 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1642   size_t total_size = 0;
1643 
1644   ::uint32_t cached_has_bits = 0;
1645   // Prevent compiler warnings about cached_has_bits being unused
1646   (void) cached_has_bits;
1647 
1648   // optional int32 ret = 1;
1649   cached_has_bits = _impl_._has_bits_[0];
1650   if (cached_has_bits & 0x00000001u) {
1651     total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
1652   }
1653 
1654   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1655     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1656   }
1657   int cached_size = ::_pbi::ToCachedSize(total_size);
1658   SetCachedSize(cached_size);
1659   return total_size;
1660 }
1661 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1662 void NapiGroReceiveExitFtraceEvent::CheckTypeAndMergeFrom(
1663     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1664   MergeFrom(*::_pbi::DownCast<const NapiGroReceiveExitFtraceEvent*>(
1665       &from));
1666 }
1667 
MergeFrom(const NapiGroReceiveExitFtraceEvent & from)1668 void NapiGroReceiveExitFtraceEvent::MergeFrom(const NapiGroReceiveExitFtraceEvent& from) {
1669   NapiGroReceiveExitFtraceEvent* const _this = this;
1670   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1671   GOOGLE_DCHECK_NE(&from, _this);
1672   ::uint32_t cached_has_bits = 0;
1673   (void) cached_has_bits;
1674 
1675   if (from._internal_has_ret()) {
1676     _this->_internal_set_ret(from._internal_ret());
1677   }
1678   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1679 }
1680 
CopyFrom(const NapiGroReceiveExitFtraceEvent & from)1681 void NapiGroReceiveExitFtraceEvent::CopyFrom(const NapiGroReceiveExitFtraceEvent& from) {
1682 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.NapiGroReceiveExitFtraceEvent)
1683   if (&from == this) return;
1684   Clear();
1685   MergeFrom(from);
1686 }
1687 
IsInitialized() const1688 bool NapiGroReceiveExitFtraceEvent::IsInitialized() const {
1689   return true;
1690 }
1691 
InternalSwap(NapiGroReceiveExitFtraceEvent * other)1692 void NapiGroReceiveExitFtraceEvent::InternalSwap(NapiGroReceiveExitFtraceEvent* other) {
1693   using std::swap;
1694   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1695   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1696   swap(_impl_.ret_, other->_impl_.ret_);
1697 }
1698 
GetTypeName() const1699 std::string NapiGroReceiveExitFtraceEvent::GetTypeName() const {
1700   return "perfetto.protos.NapiGroReceiveExitFtraceEvent";
1701 }
1702 
1703 
1704 // @@protoc_insertion_point(namespace_scope)
1705 }  // namespace protos
1706 }  // namespace perfetto
1707 PROTOBUF_NAMESPACE_OPEN
1708 template<> PROTOBUF_NOINLINE ::perfetto::protos::NetifReceiveSkbFtraceEvent*
CreateMaybeMessage(Arena * arena)1709 Arena::CreateMaybeMessage< ::perfetto::protos::NetifReceiveSkbFtraceEvent >(Arena* arena) {
1710   return Arena::CreateMessageInternal< ::perfetto::protos::NetifReceiveSkbFtraceEvent >(arena);
1711 }
1712 template<> PROTOBUF_NOINLINE ::perfetto::protos::NetDevXmitFtraceEvent*
CreateMaybeMessage(Arena * arena)1713 Arena::CreateMaybeMessage< ::perfetto::protos::NetDevXmitFtraceEvent >(Arena* arena) {
1714   return Arena::CreateMessageInternal< ::perfetto::protos::NetDevXmitFtraceEvent >(arena);
1715 }
1716 template<> PROTOBUF_NOINLINE ::perfetto::protos::NapiGroReceiveEntryFtraceEvent*
CreateMaybeMessage(Arena * arena)1717 Arena::CreateMaybeMessage< ::perfetto::protos::NapiGroReceiveEntryFtraceEvent >(Arena* arena) {
1718   return Arena::CreateMessageInternal< ::perfetto::protos::NapiGroReceiveEntryFtraceEvent >(arena);
1719 }
1720 template<> PROTOBUF_NOINLINE ::perfetto::protos::NapiGroReceiveExitFtraceEvent*
CreateMaybeMessage(Arena * arena)1721 Arena::CreateMaybeMessage< ::perfetto::protos::NapiGroReceiveExitFtraceEvent >(Arena* arena) {
1722   return Arena::CreateMessageInternal< ::perfetto::protos::NapiGroReceiveExitFtraceEvent >(arena);
1723 }
1724 PROTOBUF_NAMESPACE_CLOSE
1725 
1726 // @@protoc_insertion_point(global_scope)
1727 #include <google/protobuf/port_undef.inc>
1728