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