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