1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/power.proto
3 
4 #include "protos/perfetto/trace/ftrace/power.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 {
CpuFrequencyFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR CpuFrequencyFtraceEvent::CpuFrequencyFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.state_)*/0u
28   , /*decltype(_impl_.cpu_id_)*/0u} {}
29 struct CpuFrequencyFtraceEventDefaultTypeInternal {
CpuFrequencyFtraceEventDefaultTypeInternalperfetto::protos::CpuFrequencyFtraceEventDefaultTypeInternal30   PROTOBUF_CONSTEXPR CpuFrequencyFtraceEventDefaultTypeInternal()
31       : _instance(::_pbi::ConstantInitialized{}) {}
~CpuFrequencyFtraceEventDefaultTypeInternalperfetto::protos::CpuFrequencyFtraceEventDefaultTypeInternal32   ~CpuFrequencyFtraceEventDefaultTypeInternal() {}
33   union {  // NOLINT(misc-non-private-member-variables-in-classes)
34     CpuFrequencyFtraceEvent _instance;
35   };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CpuFrequencyFtraceEventDefaultTypeInternal _CpuFrequencyFtraceEvent_default_instance_;
CpuFrequencyLimitsFtraceEvent(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR CpuFrequencyLimitsFtraceEvent::CpuFrequencyLimitsFtraceEvent(
39     ::_pbi::ConstantInitialized): _impl_{
40     /*decltype(_impl_._has_bits_)*/{}
41   , /*decltype(_impl_._cached_size_)*/{}
42   , /*decltype(_impl_.min_freq_)*/0u
43   , /*decltype(_impl_.max_freq_)*/0u
44   , /*decltype(_impl_.cpu_id_)*/0u} {}
45 struct CpuFrequencyLimitsFtraceEventDefaultTypeInternal {
CpuFrequencyLimitsFtraceEventDefaultTypeInternalperfetto::protos::CpuFrequencyLimitsFtraceEventDefaultTypeInternal46   PROTOBUF_CONSTEXPR CpuFrequencyLimitsFtraceEventDefaultTypeInternal()
47       : _instance(::_pbi::ConstantInitialized{}) {}
~CpuFrequencyLimitsFtraceEventDefaultTypeInternalperfetto::protos::CpuFrequencyLimitsFtraceEventDefaultTypeInternal48   ~CpuFrequencyLimitsFtraceEventDefaultTypeInternal() {}
49   union {  // NOLINT(misc-non-private-member-variables-in-classes)
50     CpuFrequencyLimitsFtraceEvent _instance;
51   };
52 };
53 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CpuFrequencyLimitsFtraceEventDefaultTypeInternal _CpuFrequencyLimitsFtraceEvent_default_instance_;
CpuIdleFtraceEvent(::_pbi::ConstantInitialized)54 PROTOBUF_CONSTEXPR CpuIdleFtraceEvent::CpuIdleFtraceEvent(
55     ::_pbi::ConstantInitialized): _impl_{
56     /*decltype(_impl_._has_bits_)*/{}
57   , /*decltype(_impl_._cached_size_)*/{}
58   , /*decltype(_impl_.state_)*/0u
59   , /*decltype(_impl_.cpu_id_)*/0u} {}
60 struct CpuIdleFtraceEventDefaultTypeInternal {
CpuIdleFtraceEventDefaultTypeInternalperfetto::protos::CpuIdleFtraceEventDefaultTypeInternal61   PROTOBUF_CONSTEXPR CpuIdleFtraceEventDefaultTypeInternal()
62       : _instance(::_pbi::ConstantInitialized{}) {}
~CpuIdleFtraceEventDefaultTypeInternalperfetto::protos::CpuIdleFtraceEventDefaultTypeInternal63   ~CpuIdleFtraceEventDefaultTypeInternal() {}
64   union {  // NOLINT(misc-non-private-member-variables-in-classes)
65     CpuIdleFtraceEvent _instance;
66   };
67 };
68 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CpuIdleFtraceEventDefaultTypeInternal _CpuIdleFtraceEvent_default_instance_;
ClockEnableFtraceEvent(::_pbi::ConstantInitialized)69 PROTOBUF_CONSTEXPR ClockEnableFtraceEvent::ClockEnableFtraceEvent(
70     ::_pbi::ConstantInitialized): _impl_{
71     /*decltype(_impl_._has_bits_)*/{}
72   , /*decltype(_impl_._cached_size_)*/{}
73   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
74   , /*decltype(_impl_.state_)*/::uint64_t{0u}
75   , /*decltype(_impl_.cpu_id_)*/::uint64_t{0u}} {}
76 struct ClockEnableFtraceEventDefaultTypeInternal {
ClockEnableFtraceEventDefaultTypeInternalperfetto::protos::ClockEnableFtraceEventDefaultTypeInternal77   PROTOBUF_CONSTEXPR ClockEnableFtraceEventDefaultTypeInternal()
78       : _instance(::_pbi::ConstantInitialized{}) {}
~ClockEnableFtraceEventDefaultTypeInternalperfetto::protos::ClockEnableFtraceEventDefaultTypeInternal79   ~ClockEnableFtraceEventDefaultTypeInternal() {}
80   union {  // NOLINT(misc-non-private-member-variables-in-classes)
81     ClockEnableFtraceEvent _instance;
82   };
83 };
84 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClockEnableFtraceEventDefaultTypeInternal _ClockEnableFtraceEvent_default_instance_;
ClockDisableFtraceEvent(::_pbi::ConstantInitialized)85 PROTOBUF_CONSTEXPR ClockDisableFtraceEvent::ClockDisableFtraceEvent(
86     ::_pbi::ConstantInitialized): _impl_{
87     /*decltype(_impl_._has_bits_)*/{}
88   , /*decltype(_impl_._cached_size_)*/{}
89   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
90   , /*decltype(_impl_.state_)*/::uint64_t{0u}
91   , /*decltype(_impl_.cpu_id_)*/::uint64_t{0u}} {}
92 struct ClockDisableFtraceEventDefaultTypeInternal {
ClockDisableFtraceEventDefaultTypeInternalperfetto::protos::ClockDisableFtraceEventDefaultTypeInternal93   PROTOBUF_CONSTEXPR ClockDisableFtraceEventDefaultTypeInternal()
94       : _instance(::_pbi::ConstantInitialized{}) {}
~ClockDisableFtraceEventDefaultTypeInternalperfetto::protos::ClockDisableFtraceEventDefaultTypeInternal95   ~ClockDisableFtraceEventDefaultTypeInternal() {}
96   union {  // NOLINT(misc-non-private-member-variables-in-classes)
97     ClockDisableFtraceEvent _instance;
98   };
99 };
100 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClockDisableFtraceEventDefaultTypeInternal _ClockDisableFtraceEvent_default_instance_;
ClockSetRateFtraceEvent(::_pbi::ConstantInitialized)101 PROTOBUF_CONSTEXPR ClockSetRateFtraceEvent::ClockSetRateFtraceEvent(
102     ::_pbi::ConstantInitialized): _impl_{
103     /*decltype(_impl_._has_bits_)*/{}
104   , /*decltype(_impl_._cached_size_)*/{}
105   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
106   , /*decltype(_impl_.state_)*/::uint64_t{0u}
107   , /*decltype(_impl_.cpu_id_)*/::uint64_t{0u}} {}
108 struct ClockSetRateFtraceEventDefaultTypeInternal {
ClockSetRateFtraceEventDefaultTypeInternalperfetto::protos::ClockSetRateFtraceEventDefaultTypeInternal109   PROTOBUF_CONSTEXPR ClockSetRateFtraceEventDefaultTypeInternal()
110       : _instance(::_pbi::ConstantInitialized{}) {}
~ClockSetRateFtraceEventDefaultTypeInternalperfetto::protos::ClockSetRateFtraceEventDefaultTypeInternal111   ~ClockSetRateFtraceEventDefaultTypeInternal() {}
112   union {  // NOLINT(misc-non-private-member-variables-in-classes)
113     ClockSetRateFtraceEvent _instance;
114   };
115 };
116 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClockSetRateFtraceEventDefaultTypeInternal _ClockSetRateFtraceEvent_default_instance_;
SuspendResumeFtraceEvent(::_pbi::ConstantInitialized)117 PROTOBUF_CONSTEXPR SuspendResumeFtraceEvent::SuspendResumeFtraceEvent(
118     ::_pbi::ConstantInitialized): _impl_{
119     /*decltype(_impl_._has_bits_)*/{}
120   , /*decltype(_impl_._cached_size_)*/{}
121   , /*decltype(_impl_.action_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
122   , /*decltype(_impl_.val_)*/0
123   , /*decltype(_impl_.start_)*/0u} {}
124 struct SuspendResumeFtraceEventDefaultTypeInternal {
SuspendResumeFtraceEventDefaultTypeInternalperfetto::protos::SuspendResumeFtraceEventDefaultTypeInternal125   PROTOBUF_CONSTEXPR SuspendResumeFtraceEventDefaultTypeInternal()
126       : _instance(::_pbi::ConstantInitialized{}) {}
~SuspendResumeFtraceEventDefaultTypeInternalperfetto::protos::SuspendResumeFtraceEventDefaultTypeInternal127   ~SuspendResumeFtraceEventDefaultTypeInternal() {}
128   union {  // NOLINT(misc-non-private-member-variables-in-classes)
129     SuspendResumeFtraceEvent _instance;
130   };
131 };
132 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SuspendResumeFtraceEventDefaultTypeInternal _SuspendResumeFtraceEvent_default_instance_;
GpuFrequencyFtraceEvent(::_pbi::ConstantInitialized)133 PROTOBUF_CONSTEXPR GpuFrequencyFtraceEvent::GpuFrequencyFtraceEvent(
134     ::_pbi::ConstantInitialized): _impl_{
135     /*decltype(_impl_._has_bits_)*/{}
136   , /*decltype(_impl_._cached_size_)*/{}
137   , /*decltype(_impl_.gpu_id_)*/0u
138   , /*decltype(_impl_.state_)*/0u} {}
139 struct GpuFrequencyFtraceEventDefaultTypeInternal {
GpuFrequencyFtraceEventDefaultTypeInternalperfetto::protos::GpuFrequencyFtraceEventDefaultTypeInternal140   PROTOBUF_CONSTEXPR GpuFrequencyFtraceEventDefaultTypeInternal()
141       : _instance(::_pbi::ConstantInitialized{}) {}
~GpuFrequencyFtraceEventDefaultTypeInternalperfetto::protos::GpuFrequencyFtraceEventDefaultTypeInternal142   ~GpuFrequencyFtraceEventDefaultTypeInternal() {}
143   union {  // NOLINT(misc-non-private-member-variables-in-classes)
144     GpuFrequencyFtraceEvent _instance;
145   };
146 };
147 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GpuFrequencyFtraceEventDefaultTypeInternal _GpuFrequencyFtraceEvent_default_instance_;
WakeupSourceActivateFtraceEvent(::_pbi::ConstantInitialized)148 PROTOBUF_CONSTEXPR WakeupSourceActivateFtraceEvent::WakeupSourceActivateFtraceEvent(
149     ::_pbi::ConstantInitialized): _impl_{
150     /*decltype(_impl_._has_bits_)*/{}
151   , /*decltype(_impl_._cached_size_)*/{}
152   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
153   , /*decltype(_impl_.state_)*/::uint64_t{0u}} {}
154 struct WakeupSourceActivateFtraceEventDefaultTypeInternal {
WakeupSourceActivateFtraceEventDefaultTypeInternalperfetto::protos::WakeupSourceActivateFtraceEventDefaultTypeInternal155   PROTOBUF_CONSTEXPR WakeupSourceActivateFtraceEventDefaultTypeInternal()
156       : _instance(::_pbi::ConstantInitialized{}) {}
~WakeupSourceActivateFtraceEventDefaultTypeInternalperfetto::protos::WakeupSourceActivateFtraceEventDefaultTypeInternal157   ~WakeupSourceActivateFtraceEventDefaultTypeInternal() {}
158   union {  // NOLINT(misc-non-private-member-variables-in-classes)
159     WakeupSourceActivateFtraceEvent _instance;
160   };
161 };
162 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WakeupSourceActivateFtraceEventDefaultTypeInternal _WakeupSourceActivateFtraceEvent_default_instance_;
WakeupSourceDeactivateFtraceEvent(::_pbi::ConstantInitialized)163 PROTOBUF_CONSTEXPR WakeupSourceDeactivateFtraceEvent::WakeupSourceDeactivateFtraceEvent(
164     ::_pbi::ConstantInitialized): _impl_{
165     /*decltype(_impl_._has_bits_)*/{}
166   , /*decltype(_impl_._cached_size_)*/{}
167   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
168   , /*decltype(_impl_.state_)*/::uint64_t{0u}} {}
169 struct WakeupSourceDeactivateFtraceEventDefaultTypeInternal {
WakeupSourceDeactivateFtraceEventDefaultTypeInternalperfetto::protos::WakeupSourceDeactivateFtraceEventDefaultTypeInternal170   PROTOBUF_CONSTEXPR WakeupSourceDeactivateFtraceEventDefaultTypeInternal()
171       : _instance(::_pbi::ConstantInitialized{}) {}
~WakeupSourceDeactivateFtraceEventDefaultTypeInternalperfetto::protos::WakeupSourceDeactivateFtraceEventDefaultTypeInternal172   ~WakeupSourceDeactivateFtraceEventDefaultTypeInternal() {}
173   union {  // NOLINT(misc-non-private-member-variables-in-classes)
174     WakeupSourceDeactivateFtraceEvent _instance;
175   };
176 };
177 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WakeupSourceDeactivateFtraceEventDefaultTypeInternal _WakeupSourceDeactivateFtraceEvent_default_instance_;
GpuWorkPeriodFtraceEvent(::_pbi::ConstantInitialized)178 PROTOBUF_CONSTEXPR GpuWorkPeriodFtraceEvent::GpuWorkPeriodFtraceEvent(
179     ::_pbi::ConstantInitialized): _impl_{
180     /*decltype(_impl_._has_bits_)*/{}
181   , /*decltype(_impl_._cached_size_)*/{}
182   , /*decltype(_impl_.gpu_id_)*/0u
183   , /*decltype(_impl_.uid_)*/0u
184   , /*decltype(_impl_.start_time_ns_)*/::uint64_t{0u}
185   , /*decltype(_impl_.end_time_ns_)*/::uint64_t{0u}
186   , /*decltype(_impl_.total_active_duration_ns_)*/::uint64_t{0u}} {}
187 struct GpuWorkPeriodFtraceEventDefaultTypeInternal {
GpuWorkPeriodFtraceEventDefaultTypeInternalperfetto::protos::GpuWorkPeriodFtraceEventDefaultTypeInternal188   PROTOBUF_CONSTEXPR GpuWorkPeriodFtraceEventDefaultTypeInternal()
189       : _instance(::_pbi::ConstantInitialized{}) {}
~GpuWorkPeriodFtraceEventDefaultTypeInternalperfetto::protos::GpuWorkPeriodFtraceEventDefaultTypeInternal190   ~GpuWorkPeriodFtraceEventDefaultTypeInternal() {}
191   union {  // NOLINT(misc-non-private-member-variables-in-classes)
192     GpuWorkPeriodFtraceEvent _instance;
193   };
194 };
195 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GpuWorkPeriodFtraceEventDefaultTypeInternal _GpuWorkPeriodFtraceEvent_default_instance_;
DevicePmCallbackStartFtraceEvent(::_pbi::ConstantInitialized)196 PROTOBUF_CONSTEXPR DevicePmCallbackStartFtraceEvent::DevicePmCallbackStartFtraceEvent(
197     ::_pbi::ConstantInitialized): _impl_{
198     /*decltype(_impl_._has_bits_)*/{}
199   , /*decltype(_impl_._cached_size_)*/{}
200   , /*decltype(_impl_.device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
201   , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
202   , /*decltype(_impl_.parent_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
203   , /*decltype(_impl_.pm_ops_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
204   , /*decltype(_impl_.event_)*/0} {}
205 struct DevicePmCallbackStartFtraceEventDefaultTypeInternal {
DevicePmCallbackStartFtraceEventDefaultTypeInternalperfetto::protos::DevicePmCallbackStartFtraceEventDefaultTypeInternal206   PROTOBUF_CONSTEXPR DevicePmCallbackStartFtraceEventDefaultTypeInternal()
207       : _instance(::_pbi::ConstantInitialized{}) {}
~DevicePmCallbackStartFtraceEventDefaultTypeInternalperfetto::protos::DevicePmCallbackStartFtraceEventDefaultTypeInternal208   ~DevicePmCallbackStartFtraceEventDefaultTypeInternal() {}
209   union {  // NOLINT(misc-non-private-member-variables-in-classes)
210     DevicePmCallbackStartFtraceEvent _instance;
211   };
212 };
213 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DevicePmCallbackStartFtraceEventDefaultTypeInternal _DevicePmCallbackStartFtraceEvent_default_instance_;
DevicePmCallbackEndFtraceEvent(::_pbi::ConstantInitialized)214 PROTOBUF_CONSTEXPR DevicePmCallbackEndFtraceEvent::DevicePmCallbackEndFtraceEvent(
215     ::_pbi::ConstantInitialized): _impl_{
216     /*decltype(_impl_._has_bits_)*/{}
217   , /*decltype(_impl_._cached_size_)*/{}
218   , /*decltype(_impl_.device_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
219   , /*decltype(_impl_.driver_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
220   , /*decltype(_impl_.error_)*/0} {}
221 struct DevicePmCallbackEndFtraceEventDefaultTypeInternal {
DevicePmCallbackEndFtraceEventDefaultTypeInternalperfetto::protos::DevicePmCallbackEndFtraceEventDefaultTypeInternal222   PROTOBUF_CONSTEXPR DevicePmCallbackEndFtraceEventDefaultTypeInternal()
223       : _instance(::_pbi::ConstantInitialized{}) {}
~DevicePmCallbackEndFtraceEventDefaultTypeInternalperfetto::protos::DevicePmCallbackEndFtraceEventDefaultTypeInternal224   ~DevicePmCallbackEndFtraceEventDefaultTypeInternal() {}
225   union {  // NOLINT(misc-non-private-member-variables-in-classes)
226     DevicePmCallbackEndFtraceEvent _instance;
227   };
228 };
229 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DevicePmCallbackEndFtraceEventDefaultTypeInternal _DevicePmCallbackEndFtraceEvent_default_instance_;
230 }  // namespace protos
231 }  // namespace perfetto
232 namespace perfetto {
233 namespace protos {
234 
235 // ===================================================================
236 
237 class CpuFrequencyFtraceEvent::_Internal {
238  public:
239   using HasBits = decltype(std::declval<CpuFrequencyFtraceEvent>()._impl_._has_bits_);
set_has_state(HasBits * has_bits)240   static void set_has_state(HasBits* has_bits) {
241     (*has_bits)[0] |= 1u;
242   }
set_has_cpu_id(HasBits * has_bits)243   static void set_has_cpu_id(HasBits* has_bits) {
244     (*has_bits)[0] |= 2u;
245   }
246 };
247 
CpuFrequencyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)248 CpuFrequencyFtraceEvent::CpuFrequencyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
249                          bool is_message_owned)
250   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
251   SharedCtor(arena, is_message_owned);
252   // @@protoc_insertion_point(arena_constructor:perfetto.protos.CpuFrequencyFtraceEvent)
253 }
CpuFrequencyFtraceEvent(const CpuFrequencyFtraceEvent & from)254 CpuFrequencyFtraceEvent::CpuFrequencyFtraceEvent(const CpuFrequencyFtraceEvent& from)
255   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
256   CpuFrequencyFtraceEvent* const _this = this; (void)_this;
257   new (&_impl_) Impl_{
258       decltype(_impl_._has_bits_){from._impl_._has_bits_}
259     , /*decltype(_impl_._cached_size_)*/{}
260     , decltype(_impl_.state_){}
261     , decltype(_impl_.cpu_id_){}};
262 
263   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
264   ::memcpy(&_impl_.state_, &from._impl_.state_,
265     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cpu_id_) -
266     reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
267   // @@protoc_insertion_point(copy_constructor:perfetto.protos.CpuFrequencyFtraceEvent)
268 }
269 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)270 inline void CpuFrequencyFtraceEvent::SharedCtor(
271     ::_pb::Arena* arena, bool is_message_owned) {
272   (void)arena;
273   (void)is_message_owned;
274   new (&_impl_) Impl_{
275       decltype(_impl_._has_bits_){}
276     , /*decltype(_impl_._cached_size_)*/{}
277     , decltype(_impl_.state_){0u}
278     , decltype(_impl_.cpu_id_){0u}
279   };
280 }
281 
~CpuFrequencyFtraceEvent()282 CpuFrequencyFtraceEvent::~CpuFrequencyFtraceEvent() {
283   // @@protoc_insertion_point(destructor:perfetto.protos.CpuFrequencyFtraceEvent)
284   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
285   (void)arena;
286     return;
287   }
288   SharedDtor();
289 }
290 
SharedDtor()291 inline void CpuFrequencyFtraceEvent::SharedDtor() {
292   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
293 }
294 
SetCachedSize(int size) const295 void CpuFrequencyFtraceEvent::SetCachedSize(int size) const {
296   _impl_._cached_size_.Set(size);
297 }
298 
Clear()299 void CpuFrequencyFtraceEvent::Clear() {
300 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CpuFrequencyFtraceEvent)
301   ::uint32_t cached_has_bits = 0;
302   // Prevent compiler warnings about cached_has_bits being unused
303   (void) cached_has_bits;
304 
305   cached_has_bits = _impl_._has_bits_[0];
306   if (cached_has_bits & 0x00000003u) {
307     ::memset(&_impl_.state_, 0, static_cast<size_t>(
308         reinterpret_cast<char*>(&_impl_.cpu_id_) -
309         reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
310   }
311   _impl_._has_bits_.Clear();
312   _internal_metadata_.Clear<std::string>();
313 }
314 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)315 const char* CpuFrequencyFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
316 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
317   _Internal::HasBits has_bits{};
318   while (!ctx->Done(&ptr)) {
319     ::uint32_t tag;
320     ptr = ::_pbi::ReadTag(ptr, &tag);
321     switch (tag >> 3) {
322       // optional uint32 state = 1;
323       case 1:
324         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
325           _Internal::set_has_state(&has_bits);
326           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
327           CHK_(ptr);
328         } else {
329           goto handle_unusual;
330         }
331         continue;
332       // optional uint32 cpu_id = 2;
333       case 2:
334         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
335           _Internal::set_has_cpu_id(&has_bits);
336           _impl_.cpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
337           CHK_(ptr);
338         } else {
339           goto handle_unusual;
340         }
341         continue;
342       default:
343         goto handle_unusual;
344     }  // switch
345   handle_unusual:
346     if ((tag == 0) || ((tag & 7) == 4)) {
347       CHK_(ptr);
348       ctx->SetLastTag(tag);
349       goto message_done;
350     }
351     ptr = UnknownFieldParse(
352         tag,
353         _internal_metadata_.mutable_unknown_fields<std::string>(),
354         ptr, ctx);
355     CHK_(ptr != nullptr);
356   }  // while
357 message_done:
358   _impl_._has_bits_.Or(has_bits);
359   return ptr;
360 failure:
361   ptr = nullptr;
362   goto message_done;
363 #undef CHK_
364 }
365 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const366 ::uint8_t* CpuFrequencyFtraceEvent::_InternalSerialize(
367     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
368   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CpuFrequencyFtraceEvent)
369   ::uint32_t cached_has_bits = 0;
370   (void) cached_has_bits;
371 
372   cached_has_bits = _impl_._has_bits_[0];
373   // optional uint32 state = 1;
374   if (cached_has_bits & 0x00000001u) {
375     target = stream->EnsureSpace(target);
376     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_state(), target);
377   }
378 
379   // optional uint32 cpu_id = 2;
380   if (cached_has_bits & 0x00000002u) {
381     target = stream->EnsureSpace(target);
382     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_cpu_id(), target);
383   }
384 
385   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
386     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
387         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
388   }
389   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CpuFrequencyFtraceEvent)
390   return target;
391 }
392 
ByteSizeLong() const393 size_t CpuFrequencyFtraceEvent::ByteSizeLong() const {
394 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CpuFrequencyFtraceEvent)
395   size_t total_size = 0;
396 
397   ::uint32_t cached_has_bits = 0;
398   // Prevent compiler warnings about cached_has_bits being unused
399   (void) cached_has_bits;
400 
401   cached_has_bits = _impl_._has_bits_[0];
402   if (cached_has_bits & 0x00000003u) {
403     // optional uint32 state = 1;
404     if (cached_has_bits & 0x00000001u) {
405       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_state());
406     }
407 
408     // optional uint32 cpu_id = 2;
409     if (cached_has_bits & 0x00000002u) {
410       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cpu_id());
411     }
412 
413   }
414   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
415     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
416   }
417   int cached_size = ::_pbi::ToCachedSize(total_size);
418   SetCachedSize(cached_size);
419   return total_size;
420 }
421 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)422 void CpuFrequencyFtraceEvent::CheckTypeAndMergeFrom(
423     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
424   MergeFrom(*::_pbi::DownCast<const CpuFrequencyFtraceEvent*>(
425       &from));
426 }
427 
MergeFrom(const CpuFrequencyFtraceEvent & from)428 void CpuFrequencyFtraceEvent::MergeFrom(const CpuFrequencyFtraceEvent& from) {
429   CpuFrequencyFtraceEvent* const _this = this;
430   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CpuFrequencyFtraceEvent)
431   GOOGLE_DCHECK_NE(&from, _this);
432   ::uint32_t cached_has_bits = 0;
433   (void) cached_has_bits;
434 
435   cached_has_bits = from._impl_._has_bits_[0];
436   if (cached_has_bits & 0x00000003u) {
437     if (cached_has_bits & 0x00000001u) {
438       _this->_impl_.state_ = from._impl_.state_;
439     }
440     if (cached_has_bits & 0x00000002u) {
441       _this->_impl_.cpu_id_ = from._impl_.cpu_id_;
442     }
443     _this->_impl_._has_bits_[0] |= cached_has_bits;
444   }
445   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
446 }
447 
CopyFrom(const CpuFrequencyFtraceEvent & from)448 void CpuFrequencyFtraceEvent::CopyFrom(const CpuFrequencyFtraceEvent& from) {
449 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CpuFrequencyFtraceEvent)
450   if (&from == this) return;
451   Clear();
452   MergeFrom(from);
453 }
454 
IsInitialized() const455 bool CpuFrequencyFtraceEvent::IsInitialized() const {
456   return true;
457 }
458 
InternalSwap(CpuFrequencyFtraceEvent * other)459 void CpuFrequencyFtraceEvent::InternalSwap(CpuFrequencyFtraceEvent* other) {
460   using std::swap;
461   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
462   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
463   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
464       PROTOBUF_FIELD_OFFSET(CpuFrequencyFtraceEvent, _impl_.cpu_id_)
465       + sizeof(CpuFrequencyFtraceEvent::_impl_.cpu_id_)  // NOLINT
466       - PROTOBUF_FIELD_OFFSET(CpuFrequencyFtraceEvent, _impl_.state_)>(
467           reinterpret_cast<char*>(&_impl_.state_),
468           reinterpret_cast<char*>(&other->_impl_.state_));
469 }
470 
GetTypeName() const471 std::string CpuFrequencyFtraceEvent::GetTypeName() const {
472   return "perfetto.protos.CpuFrequencyFtraceEvent";
473 }
474 
475 
476 // ===================================================================
477 
478 class CpuFrequencyLimitsFtraceEvent::_Internal {
479  public:
480   using HasBits = decltype(std::declval<CpuFrequencyLimitsFtraceEvent>()._impl_._has_bits_);
set_has_min_freq(HasBits * has_bits)481   static void set_has_min_freq(HasBits* has_bits) {
482     (*has_bits)[0] |= 1u;
483   }
set_has_max_freq(HasBits * has_bits)484   static void set_has_max_freq(HasBits* has_bits) {
485     (*has_bits)[0] |= 2u;
486   }
set_has_cpu_id(HasBits * has_bits)487   static void set_has_cpu_id(HasBits* has_bits) {
488     (*has_bits)[0] |= 4u;
489   }
490 };
491 
CpuFrequencyLimitsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)492 CpuFrequencyLimitsFtraceEvent::CpuFrequencyLimitsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
493                          bool is_message_owned)
494   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
495   SharedCtor(arena, is_message_owned);
496   // @@protoc_insertion_point(arena_constructor:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
497 }
CpuFrequencyLimitsFtraceEvent(const CpuFrequencyLimitsFtraceEvent & from)498 CpuFrequencyLimitsFtraceEvent::CpuFrequencyLimitsFtraceEvent(const CpuFrequencyLimitsFtraceEvent& from)
499   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
500   CpuFrequencyLimitsFtraceEvent* const _this = this; (void)_this;
501   new (&_impl_) Impl_{
502       decltype(_impl_._has_bits_){from._impl_._has_bits_}
503     , /*decltype(_impl_._cached_size_)*/{}
504     , decltype(_impl_.min_freq_){}
505     , decltype(_impl_.max_freq_){}
506     , decltype(_impl_.cpu_id_){}};
507 
508   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
509   ::memcpy(&_impl_.min_freq_, &from._impl_.min_freq_,
510     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cpu_id_) -
511     reinterpret_cast<char*>(&_impl_.min_freq_)) + sizeof(_impl_.cpu_id_));
512   // @@protoc_insertion_point(copy_constructor:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
513 }
514 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)515 inline void CpuFrequencyLimitsFtraceEvent::SharedCtor(
516     ::_pb::Arena* arena, bool is_message_owned) {
517   (void)arena;
518   (void)is_message_owned;
519   new (&_impl_) Impl_{
520       decltype(_impl_._has_bits_){}
521     , /*decltype(_impl_._cached_size_)*/{}
522     , decltype(_impl_.min_freq_){0u}
523     , decltype(_impl_.max_freq_){0u}
524     , decltype(_impl_.cpu_id_){0u}
525   };
526 }
527 
~CpuFrequencyLimitsFtraceEvent()528 CpuFrequencyLimitsFtraceEvent::~CpuFrequencyLimitsFtraceEvent() {
529   // @@protoc_insertion_point(destructor:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
530   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
531   (void)arena;
532     return;
533   }
534   SharedDtor();
535 }
536 
SharedDtor()537 inline void CpuFrequencyLimitsFtraceEvent::SharedDtor() {
538   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
539 }
540 
SetCachedSize(int size) const541 void CpuFrequencyLimitsFtraceEvent::SetCachedSize(int size) const {
542   _impl_._cached_size_.Set(size);
543 }
544 
Clear()545 void CpuFrequencyLimitsFtraceEvent::Clear() {
546 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
547   ::uint32_t cached_has_bits = 0;
548   // Prevent compiler warnings about cached_has_bits being unused
549   (void) cached_has_bits;
550 
551   cached_has_bits = _impl_._has_bits_[0];
552   if (cached_has_bits & 0x00000007u) {
553     ::memset(&_impl_.min_freq_, 0, static_cast<size_t>(
554         reinterpret_cast<char*>(&_impl_.cpu_id_) -
555         reinterpret_cast<char*>(&_impl_.min_freq_)) + sizeof(_impl_.cpu_id_));
556   }
557   _impl_._has_bits_.Clear();
558   _internal_metadata_.Clear<std::string>();
559 }
560 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)561 const char* CpuFrequencyLimitsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
562 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
563   _Internal::HasBits has_bits{};
564   while (!ctx->Done(&ptr)) {
565     ::uint32_t tag;
566     ptr = ::_pbi::ReadTag(ptr, &tag);
567     switch (tag >> 3) {
568       // optional uint32 min_freq = 1;
569       case 1:
570         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
571           _Internal::set_has_min_freq(&has_bits);
572           _impl_.min_freq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
573           CHK_(ptr);
574         } else {
575           goto handle_unusual;
576         }
577         continue;
578       // optional uint32 max_freq = 2;
579       case 2:
580         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
581           _Internal::set_has_max_freq(&has_bits);
582           _impl_.max_freq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
583           CHK_(ptr);
584         } else {
585           goto handle_unusual;
586         }
587         continue;
588       // optional uint32 cpu_id = 3;
589       case 3:
590         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
591           _Internal::set_has_cpu_id(&has_bits);
592           _impl_.cpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
593           CHK_(ptr);
594         } else {
595           goto handle_unusual;
596         }
597         continue;
598       default:
599         goto handle_unusual;
600     }  // switch
601   handle_unusual:
602     if ((tag == 0) || ((tag & 7) == 4)) {
603       CHK_(ptr);
604       ctx->SetLastTag(tag);
605       goto message_done;
606     }
607     ptr = UnknownFieldParse(
608         tag,
609         _internal_metadata_.mutable_unknown_fields<std::string>(),
610         ptr, ctx);
611     CHK_(ptr != nullptr);
612   }  // while
613 message_done:
614   _impl_._has_bits_.Or(has_bits);
615   return ptr;
616 failure:
617   ptr = nullptr;
618   goto message_done;
619 #undef CHK_
620 }
621 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const622 ::uint8_t* CpuFrequencyLimitsFtraceEvent::_InternalSerialize(
623     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
624   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
625   ::uint32_t cached_has_bits = 0;
626   (void) cached_has_bits;
627 
628   cached_has_bits = _impl_._has_bits_[0];
629   // optional uint32 min_freq = 1;
630   if (cached_has_bits & 0x00000001u) {
631     target = stream->EnsureSpace(target);
632     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_min_freq(), target);
633   }
634 
635   // optional uint32 max_freq = 2;
636   if (cached_has_bits & 0x00000002u) {
637     target = stream->EnsureSpace(target);
638     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_max_freq(), target);
639   }
640 
641   // optional uint32 cpu_id = 3;
642   if (cached_has_bits & 0x00000004u) {
643     target = stream->EnsureSpace(target);
644     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_cpu_id(), target);
645   }
646 
647   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
648     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
649         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
650   }
651   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
652   return target;
653 }
654 
ByteSizeLong() const655 size_t CpuFrequencyLimitsFtraceEvent::ByteSizeLong() const {
656 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
657   size_t total_size = 0;
658 
659   ::uint32_t cached_has_bits = 0;
660   // Prevent compiler warnings about cached_has_bits being unused
661   (void) cached_has_bits;
662 
663   cached_has_bits = _impl_._has_bits_[0];
664   if (cached_has_bits & 0x00000007u) {
665     // optional uint32 min_freq = 1;
666     if (cached_has_bits & 0x00000001u) {
667       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_min_freq());
668     }
669 
670     // optional uint32 max_freq = 2;
671     if (cached_has_bits & 0x00000002u) {
672       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_max_freq());
673     }
674 
675     // optional uint32 cpu_id = 3;
676     if (cached_has_bits & 0x00000004u) {
677       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cpu_id());
678     }
679 
680   }
681   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
682     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
683   }
684   int cached_size = ::_pbi::ToCachedSize(total_size);
685   SetCachedSize(cached_size);
686   return total_size;
687 }
688 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)689 void CpuFrequencyLimitsFtraceEvent::CheckTypeAndMergeFrom(
690     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
691   MergeFrom(*::_pbi::DownCast<const CpuFrequencyLimitsFtraceEvent*>(
692       &from));
693 }
694 
MergeFrom(const CpuFrequencyLimitsFtraceEvent & from)695 void CpuFrequencyLimitsFtraceEvent::MergeFrom(const CpuFrequencyLimitsFtraceEvent& from) {
696   CpuFrequencyLimitsFtraceEvent* const _this = this;
697   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
698   GOOGLE_DCHECK_NE(&from, _this);
699   ::uint32_t cached_has_bits = 0;
700   (void) cached_has_bits;
701 
702   cached_has_bits = from._impl_._has_bits_[0];
703   if (cached_has_bits & 0x00000007u) {
704     if (cached_has_bits & 0x00000001u) {
705       _this->_impl_.min_freq_ = from._impl_.min_freq_;
706     }
707     if (cached_has_bits & 0x00000002u) {
708       _this->_impl_.max_freq_ = from._impl_.max_freq_;
709     }
710     if (cached_has_bits & 0x00000004u) {
711       _this->_impl_.cpu_id_ = from._impl_.cpu_id_;
712     }
713     _this->_impl_._has_bits_[0] |= cached_has_bits;
714   }
715   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
716 }
717 
CopyFrom(const CpuFrequencyLimitsFtraceEvent & from)718 void CpuFrequencyLimitsFtraceEvent::CopyFrom(const CpuFrequencyLimitsFtraceEvent& from) {
719 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CpuFrequencyLimitsFtraceEvent)
720   if (&from == this) return;
721   Clear();
722   MergeFrom(from);
723 }
724 
IsInitialized() const725 bool CpuFrequencyLimitsFtraceEvent::IsInitialized() const {
726   return true;
727 }
728 
InternalSwap(CpuFrequencyLimitsFtraceEvent * other)729 void CpuFrequencyLimitsFtraceEvent::InternalSwap(CpuFrequencyLimitsFtraceEvent* other) {
730   using std::swap;
731   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
732   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
733   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
734       PROTOBUF_FIELD_OFFSET(CpuFrequencyLimitsFtraceEvent, _impl_.cpu_id_)
735       + sizeof(CpuFrequencyLimitsFtraceEvent::_impl_.cpu_id_)  // NOLINT
736       - PROTOBUF_FIELD_OFFSET(CpuFrequencyLimitsFtraceEvent, _impl_.min_freq_)>(
737           reinterpret_cast<char*>(&_impl_.min_freq_),
738           reinterpret_cast<char*>(&other->_impl_.min_freq_));
739 }
740 
GetTypeName() const741 std::string CpuFrequencyLimitsFtraceEvent::GetTypeName() const {
742   return "perfetto.protos.CpuFrequencyLimitsFtraceEvent";
743 }
744 
745 
746 // ===================================================================
747 
748 class CpuIdleFtraceEvent::_Internal {
749  public:
750   using HasBits = decltype(std::declval<CpuIdleFtraceEvent>()._impl_._has_bits_);
set_has_state(HasBits * has_bits)751   static void set_has_state(HasBits* has_bits) {
752     (*has_bits)[0] |= 1u;
753   }
set_has_cpu_id(HasBits * has_bits)754   static void set_has_cpu_id(HasBits* has_bits) {
755     (*has_bits)[0] |= 2u;
756   }
757 };
758 
CpuIdleFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)759 CpuIdleFtraceEvent::CpuIdleFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
760                          bool is_message_owned)
761   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
762   SharedCtor(arena, is_message_owned);
763   // @@protoc_insertion_point(arena_constructor:perfetto.protos.CpuIdleFtraceEvent)
764 }
CpuIdleFtraceEvent(const CpuIdleFtraceEvent & from)765 CpuIdleFtraceEvent::CpuIdleFtraceEvent(const CpuIdleFtraceEvent& from)
766   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
767   CpuIdleFtraceEvent* const _this = this; (void)_this;
768   new (&_impl_) Impl_{
769       decltype(_impl_._has_bits_){from._impl_._has_bits_}
770     , /*decltype(_impl_._cached_size_)*/{}
771     , decltype(_impl_.state_){}
772     , decltype(_impl_.cpu_id_){}};
773 
774   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
775   ::memcpy(&_impl_.state_, &from._impl_.state_,
776     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cpu_id_) -
777     reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
778   // @@protoc_insertion_point(copy_constructor:perfetto.protos.CpuIdleFtraceEvent)
779 }
780 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)781 inline void CpuIdleFtraceEvent::SharedCtor(
782     ::_pb::Arena* arena, bool is_message_owned) {
783   (void)arena;
784   (void)is_message_owned;
785   new (&_impl_) Impl_{
786       decltype(_impl_._has_bits_){}
787     , /*decltype(_impl_._cached_size_)*/{}
788     , decltype(_impl_.state_){0u}
789     , decltype(_impl_.cpu_id_){0u}
790   };
791 }
792 
~CpuIdleFtraceEvent()793 CpuIdleFtraceEvent::~CpuIdleFtraceEvent() {
794   // @@protoc_insertion_point(destructor:perfetto.protos.CpuIdleFtraceEvent)
795   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
796   (void)arena;
797     return;
798   }
799   SharedDtor();
800 }
801 
SharedDtor()802 inline void CpuIdleFtraceEvent::SharedDtor() {
803   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
804 }
805 
SetCachedSize(int size) const806 void CpuIdleFtraceEvent::SetCachedSize(int size) const {
807   _impl_._cached_size_.Set(size);
808 }
809 
Clear()810 void CpuIdleFtraceEvent::Clear() {
811 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CpuIdleFtraceEvent)
812   ::uint32_t cached_has_bits = 0;
813   // Prevent compiler warnings about cached_has_bits being unused
814   (void) cached_has_bits;
815 
816   cached_has_bits = _impl_._has_bits_[0];
817   if (cached_has_bits & 0x00000003u) {
818     ::memset(&_impl_.state_, 0, static_cast<size_t>(
819         reinterpret_cast<char*>(&_impl_.cpu_id_) -
820         reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
821   }
822   _impl_._has_bits_.Clear();
823   _internal_metadata_.Clear<std::string>();
824 }
825 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)826 const char* CpuIdleFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
827 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
828   _Internal::HasBits has_bits{};
829   while (!ctx->Done(&ptr)) {
830     ::uint32_t tag;
831     ptr = ::_pbi::ReadTag(ptr, &tag);
832     switch (tag >> 3) {
833       // optional uint32 state = 1;
834       case 1:
835         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
836           _Internal::set_has_state(&has_bits);
837           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
838           CHK_(ptr);
839         } else {
840           goto handle_unusual;
841         }
842         continue;
843       // optional uint32 cpu_id = 2;
844       case 2:
845         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
846           _Internal::set_has_cpu_id(&has_bits);
847           _impl_.cpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
848           CHK_(ptr);
849         } else {
850           goto handle_unusual;
851         }
852         continue;
853       default:
854         goto handle_unusual;
855     }  // switch
856   handle_unusual:
857     if ((tag == 0) || ((tag & 7) == 4)) {
858       CHK_(ptr);
859       ctx->SetLastTag(tag);
860       goto message_done;
861     }
862     ptr = UnknownFieldParse(
863         tag,
864         _internal_metadata_.mutable_unknown_fields<std::string>(),
865         ptr, ctx);
866     CHK_(ptr != nullptr);
867   }  // while
868 message_done:
869   _impl_._has_bits_.Or(has_bits);
870   return ptr;
871 failure:
872   ptr = nullptr;
873   goto message_done;
874 #undef CHK_
875 }
876 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const877 ::uint8_t* CpuIdleFtraceEvent::_InternalSerialize(
878     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
879   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CpuIdleFtraceEvent)
880   ::uint32_t cached_has_bits = 0;
881   (void) cached_has_bits;
882 
883   cached_has_bits = _impl_._has_bits_[0];
884   // optional uint32 state = 1;
885   if (cached_has_bits & 0x00000001u) {
886     target = stream->EnsureSpace(target);
887     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_state(), target);
888   }
889 
890   // optional uint32 cpu_id = 2;
891   if (cached_has_bits & 0x00000002u) {
892     target = stream->EnsureSpace(target);
893     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_cpu_id(), target);
894   }
895 
896   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
897     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
898         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
899   }
900   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CpuIdleFtraceEvent)
901   return target;
902 }
903 
ByteSizeLong() const904 size_t CpuIdleFtraceEvent::ByteSizeLong() const {
905 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CpuIdleFtraceEvent)
906   size_t total_size = 0;
907 
908   ::uint32_t cached_has_bits = 0;
909   // Prevent compiler warnings about cached_has_bits being unused
910   (void) cached_has_bits;
911 
912   cached_has_bits = _impl_._has_bits_[0];
913   if (cached_has_bits & 0x00000003u) {
914     // optional uint32 state = 1;
915     if (cached_has_bits & 0x00000001u) {
916       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_state());
917     }
918 
919     // optional uint32 cpu_id = 2;
920     if (cached_has_bits & 0x00000002u) {
921       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cpu_id());
922     }
923 
924   }
925   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
926     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
927   }
928   int cached_size = ::_pbi::ToCachedSize(total_size);
929   SetCachedSize(cached_size);
930   return total_size;
931 }
932 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)933 void CpuIdleFtraceEvent::CheckTypeAndMergeFrom(
934     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
935   MergeFrom(*::_pbi::DownCast<const CpuIdleFtraceEvent*>(
936       &from));
937 }
938 
MergeFrom(const CpuIdleFtraceEvent & from)939 void CpuIdleFtraceEvent::MergeFrom(const CpuIdleFtraceEvent& from) {
940   CpuIdleFtraceEvent* const _this = this;
941   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CpuIdleFtraceEvent)
942   GOOGLE_DCHECK_NE(&from, _this);
943   ::uint32_t cached_has_bits = 0;
944   (void) cached_has_bits;
945 
946   cached_has_bits = from._impl_._has_bits_[0];
947   if (cached_has_bits & 0x00000003u) {
948     if (cached_has_bits & 0x00000001u) {
949       _this->_impl_.state_ = from._impl_.state_;
950     }
951     if (cached_has_bits & 0x00000002u) {
952       _this->_impl_.cpu_id_ = from._impl_.cpu_id_;
953     }
954     _this->_impl_._has_bits_[0] |= cached_has_bits;
955   }
956   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
957 }
958 
CopyFrom(const CpuIdleFtraceEvent & from)959 void CpuIdleFtraceEvent::CopyFrom(const CpuIdleFtraceEvent& from) {
960 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CpuIdleFtraceEvent)
961   if (&from == this) return;
962   Clear();
963   MergeFrom(from);
964 }
965 
IsInitialized() const966 bool CpuIdleFtraceEvent::IsInitialized() const {
967   return true;
968 }
969 
InternalSwap(CpuIdleFtraceEvent * other)970 void CpuIdleFtraceEvent::InternalSwap(CpuIdleFtraceEvent* other) {
971   using std::swap;
972   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
973   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
974   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
975       PROTOBUF_FIELD_OFFSET(CpuIdleFtraceEvent, _impl_.cpu_id_)
976       + sizeof(CpuIdleFtraceEvent::_impl_.cpu_id_)  // NOLINT
977       - PROTOBUF_FIELD_OFFSET(CpuIdleFtraceEvent, _impl_.state_)>(
978           reinterpret_cast<char*>(&_impl_.state_),
979           reinterpret_cast<char*>(&other->_impl_.state_));
980 }
981 
GetTypeName() const982 std::string CpuIdleFtraceEvent::GetTypeName() const {
983   return "perfetto.protos.CpuIdleFtraceEvent";
984 }
985 
986 
987 // ===================================================================
988 
989 class ClockEnableFtraceEvent::_Internal {
990  public:
991   using HasBits = decltype(std::declval<ClockEnableFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)992   static void set_has_name(HasBits* has_bits) {
993     (*has_bits)[0] |= 1u;
994   }
set_has_state(HasBits * has_bits)995   static void set_has_state(HasBits* has_bits) {
996     (*has_bits)[0] |= 2u;
997   }
set_has_cpu_id(HasBits * has_bits)998   static void set_has_cpu_id(HasBits* has_bits) {
999     (*has_bits)[0] |= 4u;
1000   }
1001 };
1002 
ClockEnableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1003 ClockEnableFtraceEvent::ClockEnableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1004                          bool is_message_owned)
1005   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1006   SharedCtor(arena, is_message_owned);
1007   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ClockEnableFtraceEvent)
1008 }
ClockEnableFtraceEvent(const ClockEnableFtraceEvent & from)1009 ClockEnableFtraceEvent::ClockEnableFtraceEvent(const ClockEnableFtraceEvent& from)
1010   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1011   ClockEnableFtraceEvent* const _this = this; (void)_this;
1012   new (&_impl_) Impl_{
1013       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1014     , /*decltype(_impl_._cached_size_)*/{}
1015     , decltype(_impl_.name_){}
1016     , decltype(_impl_.state_){}
1017     , decltype(_impl_.cpu_id_){}};
1018 
1019   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1020   _impl_.name_.InitDefault();
1021   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1022     _impl_.name_.Set("", GetArenaForAllocation());
1023   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1024   if (from._internal_has_name()) {
1025     _this->_impl_.name_.Set(from._internal_name(),
1026       _this->GetArenaForAllocation());
1027   }
1028   ::memcpy(&_impl_.state_, &from._impl_.state_,
1029     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cpu_id_) -
1030     reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
1031   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ClockEnableFtraceEvent)
1032 }
1033 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1034 inline void ClockEnableFtraceEvent::SharedCtor(
1035     ::_pb::Arena* arena, bool is_message_owned) {
1036   (void)arena;
1037   (void)is_message_owned;
1038   new (&_impl_) Impl_{
1039       decltype(_impl_._has_bits_){}
1040     , /*decltype(_impl_._cached_size_)*/{}
1041     , decltype(_impl_.name_){}
1042     , decltype(_impl_.state_){::uint64_t{0u}}
1043     , decltype(_impl_.cpu_id_){::uint64_t{0u}}
1044   };
1045   _impl_.name_.InitDefault();
1046   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1047     _impl_.name_.Set("", GetArenaForAllocation());
1048   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1049 }
1050 
~ClockEnableFtraceEvent()1051 ClockEnableFtraceEvent::~ClockEnableFtraceEvent() {
1052   // @@protoc_insertion_point(destructor:perfetto.protos.ClockEnableFtraceEvent)
1053   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1054   (void)arena;
1055     return;
1056   }
1057   SharedDtor();
1058 }
1059 
SharedDtor()1060 inline void ClockEnableFtraceEvent::SharedDtor() {
1061   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1062   _impl_.name_.Destroy();
1063 }
1064 
SetCachedSize(int size) const1065 void ClockEnableFtraceEvent::SetCachedSize(int size) const {
1066   _impl_._cached_size_.Set(size);
1067 }
1068 
Clear()1069 void ClockEnableFtraceEvent::Clear() {
1070 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ClockEnableFtraceEvent)
1071   ::uint32_t cached_has_bits = 0;
1072   // Prevent compiler warnings about cached_has_bits being unused
1073   (void) cached_has_bits;
1074 
1075   cached_has_bits = _impl_._has_bits_[0];
1076   if (cached_has_bits & 0x00000001u) {
1077     _impl_.name_.ClearNonDefaultToEmpty();
1078   }
1079   if (cached_has_bits & 0x00000006u) {
1080     ::memset(&_impl_.state_, 0, static_cast<size_t>(
1081         reinterpret_cast<char*>(&_impl_.cpu_id_) -
1082         reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
1083   }
1084   _impl_._has_bits_.Clear();
1085   _internal_metadata_.Clear<std::string>();
1086 }
1087 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1088 const char* ClockEnableFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1089 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1090   _Internal::HasBits has_bits{};
1091   while (!ctx->Done(&ptr)) {
1092     ::uint32_t tag;
1093     ptr = ::_pbi::ReadTag(ptr, &tag);
1094     switch (tag >> 3) {
1095       // optional string name = 1;
1096       case 1:
1097         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1098           auto str = _internal_mutable_name();
1099           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1100           CHK_(ptr);
1101         } else {
1102           goto handle_unusual;
1103         }
1104         continue;
1105       // optional uint64 state = 2;
1106       case 2:
1107         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1108           _Internal::set_has_state(&has_bits);
1109           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1110           CHK_(ptr);
1111         } else {
1112           goto handle_unusual;
1113         }
1114         continue;
1115       // optional uint64 cpu_id = 3;
1116       case 3:
1117         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1118           _Internal::set_has_cpu_id(&has_bits);
1119           _impl_.cpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1120           CHK_(ptr);
1121         } else {
1122           goto handle_unusual;
1123         }
1124         continue;
1125       default:
1126         goto handle_unusual;
1127     }  // switch
1128   handle_unusual:
1129     if ((tag == 0) || ((tag & 7) == 4)) {
1130       CHK_(ptr);
1131       ctx->SetLastTag(tag);
1132       goto message_done;
1133     }
1134     ptr = UnknownFieldParse(
1135         tag,
1136         _internal_metadata_.mutable_unknown_fields<std::string>(),
1137         ptr, ctx);
1138     CHK_(ptr != nullptr);
1139   }  // while
1140 message_done:
1141   _impl_._has_bits_.Or(has_bits);
1142   return ptr;
1143 failure:
1144   ptr = nullptr;
1145   goto message_done;
1146 #undef CHK_
1147 }
1148 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1149 ::uint8_t* ClockEnableFtraceEvent::_InternalSerialize(
1150     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1151   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ClockEnableFtraceEvent)
1152   ::uint32_t cached_has_bits = 0;
1153   (void) cached_has_bits;
1154 
1155   cached_has_bits = _impl_._has_bits_[0];
1156   // optional string name = 1;
1157   if (cached_has_bits & 0x00000001u) {
1158     target = stream->WriteStringMaybeAliased(
1159         1, this->_internal_name(), target);
1160   }
1161 
1162   // optional uint64 state = 2;
1163   if (cached_has_bits & 0x00000002u) {
1164     target = stream->EnsureSpace(target);
1165     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_state(), target);
1166   }
1167 
1168   // optional uint64 cpu_id = 3;
1169   if (cached_has_bits & 0x00000004u) {
1170     target = stream->EnsureSpace(target);
1171     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_cpu_id(), target);
1172   }
1173 
1174   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1175     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1176         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1177   }
1178   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ClockEnableFtraceEvent)
1179   return target;
1180 }
1181 
ByteSizeLong() const1182 size_t ClockEnableFtraceEvent::ByteSizeLong() const {
1183 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ClockEnableFtraceEvent)
1184   size_t total_size = 0;
1185 
1186   ::uint32_t cached_has_bits = 0;
1187   // Prevent compiler warnings about cached_has_bits being unused
1188   (void) cached_has_bits;
1189 
1190   cached_has_bits = _impl_._has_bits_[0];
1191   if (cached_has_bits & 0x00000007u) {
1192     // optional string name = 1;
1193     if (cached_has_bits & 0x00000001u) {
1194       total_size += 1 +
1195         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1196           this->_internal_name());
1197     }
1198 
1199     // optional uint64 state = 2;
1200     if (cached_has_bits & 0x00000002u) {
1201       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_state());
1202     }
1203 
1204     // optional uint64 cpu_id = 3;
1205     if (cached_has_bits & 0x00000004u) {
1206       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cpu_id());
1207     }
1208 
1209   }
1210   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1211     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1212   }
1213   int cached_size = ::_pbi::ToCachedSize(total_size);
1214   SetCachedSize(cached_size);
1215   return total_size;
1216 }
1217 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1218 void ClockEnableFtraceEvent::CheckTypeAndMergeFrom(
1219     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1220   MergeFrom(*::_pbi::DownCast<const ClockEnableFtraceEvent*>(
1221       &from));
1222 }
1223 
MergeFrom(const ClockEnableFtraceEvent & from)1224 void ClockEnableFtraceEvent::MergeFrom(const ClockEnableFtraceEvent& from) {
1225   ClockEnableFtraceEvent* const _this = this;
1226   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ClockEnableFtraceEvent)
1227   GOOGLE_DCHECK_NE(&from, _this);
1228   ::uint32_t cached_has_bits = 0;
1229   (void) cached_has_bits;
1230 
1231   cached_has_bits = from._impl_._has_bits_[0];
1232   if (cached_has_bits & 0x00000007u) {
1233     if (cached_has_bits & 0x00000001u) {
1234       _this->_internal_set_name(from._internal_name());
1235     }
1236     if (cached_has_bits & 0x00000002u) {
1237       _this->_impl_.state_ = from._impl_.state_;
1238     }
1239     if (cached_has_bits & 0x00000004u) {
1240       _this->_impl_.cpu_id_ = from._impl_.cpu_id_;
1241     }
1242     _this->_impl_._has_bits_[0] |= cached_has_bits;
1243   }
1244   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1245 }
1246 
CopyFrom(const ClockEnableFtraceEvent & from)1247 void ClockEnableFtraceEvent::CopyFrom(const ClockEnableFtraceEvent& from) {
1248 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ClockEnableFtraceEvent)
1249   if (&from == this) return;
1250   Clear();
1251   MergeFrom(from);
1252 }
1253 
IsInitialized() const1254 bool ClockEnableFtraceEvent::IsInitialized() const {
1255   return true;
1256 }
1257 
InternalSwap(ClockEnableFtraceEvent * other)1258 void ClockEnableFtraceEvent::InternalSwap(ClockEnableFtraceEvent* other) {
1259   using std::swap;
1260   auto* lhs_arena = GetArenaForAllocation();
1261   auto* rhs_arena = other->GetArenaForAllocation();
1262   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1263   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1264   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1265       &_impl_.name_, lhs_arena,
1266       &other->_impl_.name_, rhs_arena
1267   );
1268   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1269       PROTOBUF_FIELD_OFFSET(ClockEnableFtraceEvent, _impl_.cpu_id_)
1270       + sizeof(ClockEnableFtraceEvent::_impl_.cpu_id_)  // NOLINT
1271       - PROTOBUF_FIELD_OFFSET(ClockEnableFtraceEvent, _impl_.state_)>(
1272           reinterpret_cast<char*>(&_impl_.state_),
1273           reinterpret_cast<char*>(&other->_impl_.state_));
1274 }
1275 
GetTypeName() const1276 std::string ClockEnableFtraceEvent::GetTypeName() const {
1277   return "perfetto.protos.ClockEnableFtraceEvent";
1278 }
1279 
1280 
1281 // ===================================================================
1282 
1283 class ClockDisableFtraceEvent::_Internal {
1284  public:
1285   using HasBits = decltype(std::declval<ClockDisableFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)1286   static void set_has_name(HasBits* has_bits) {
1287     (*has_bits)[0] |= 1u;
1288   }
set_has_state(HasBits * has_bits)1289   static void set_has_state(HasBits* has_bits) {
1290     (*has_bits)[0] |= 2u;
1291   }
set_has_cpu_id(HasBits * has_bits)1292   static void set_has_cpu_id(HasBits* has_bits) {
1293     (*has_bits)[0] |= 4u;
1294   }
1295 };
1296 
ClockDisableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1297 ClockDisableFtraceEvent::ClockDisableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1298                          bool is_message_owned)
1299   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1300   SharedCtor(arena, is_message_owned);
1301   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ClockDisableFtraceEvent)
1302 }
ClockDisableFtraceEvent(const ClockDisableFtraceEvent & from)1303 ClockDisableFtraceEvent::ClockDisableFtraceEvent(const ClockDisableFtraceEvent& from)
1304   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1305   ClockDisableFtraceEvent* const _this = this; (void)_this;
1306   new (&_impl_) Impl_{
1307       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1308     , /*decltype(_impl_._cached_size_)*/{}
1309     , decltype(_impl_.name_){}
1310     , decltype(_impl_.state_){}
1311     , decltype(_impl_.cpu_id_){}};
1312 
1313   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1314   _impl_.name_.InitDefault();
1315   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1316     _impl_.name_.Set("", GetArenaForAllocation());
1317   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1318   if (from._internal_has_name()) {
1319     _this->_impl_.name_.Set(from._internal_name(),
1320       _this->GetArenaForAllocation());
1321   }
1322   ::memcpy(&_impl_.state_, &from._impl_.state_,
1323     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cpu_id_) -
1324     reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
1325   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ClockDisableFtraceEvent)
1326 }
1327 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1328 inline void ClockDisableFtraceEvent::SharedCtor(
1329     ::_pb::Arena* arena, bool is_message_owned) {
1330   (void)arena;
1331   (void)is_message_owned;
1332   new (&_impl_) Impl_{
1333       decltype(_impl_._has_bits_){}
1334     , /*decltype(_impl_._cached_size_)*/{}
1335     , decltype(_impl_.name_){}
1336     , decltype(_impl_.state_){::uint64_t{0u}}
1337     , decltype(_impl_.cpu_id_){::uint64_t{0u}}
1338   };
1339   _impl_.name_.InitDefault();
1340   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1341     _impl_.name_.Set("", GetArenaForAllocation());
1342   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1343 }
1344 
~ClockDisableFtraceEvent()1345 ClockDisableFtraceEvent::~ClockDisableFtraceEvent() {
1346   // @@protoc_insertion_point(destructor:perfetto.protos.ClockDisableFtraceEvent)
1347   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1348   (void)arena;
1349     return;
1350   }
1351   SharedDtor();
1352 }
1353 
SharedDtor()1354 inline void ClockDisableFtraceEvent::SharedDtor() {
1355   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1356   _impl_.name_.Destroy();
1357 }
1358 
SetCachedSize(int size) const1359 void ClockDisableFtraceEvent::SetCachedSize(int size) const {
1360   _impl_._cached_size_.Set(size);
1361 }
1362 
Clear()1363 void ClockDisableFtraceEvent::Clear() {
1364 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ClockDisableFtraceEvent)
1365   ::uint32_t cached_has_bits = 0;
1366   // Prevent compiler warnings about cached_has_bits being unused
1367   (void) cached_has_bits;
1368 
1369   cached_has_bits = _impl_._has_bits_[0];
1370   if (cached_has_bits & 0x00000001u) {
1371     _impl_.name_.ClearNonDefaultToEmpty();
1372   }
1373   if (cached_has_bits & 0x00000006u) {
1374     ::memset(&_impl_.state_, 0, static_cast<size_t>(
1375         reinterpret_cast<char*>(&_impl_.cpu_id_) -
1376         reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
1377   }
1378   _impl_._has_bits_.Clear();
1379   _internal_metadata_.Clear<std::string>();
1380 }
1381 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1382 const char* ClockDisableFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1383 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1384   _Internal::HasBits has_bits{};
1385   while (!ctx->Done(&ptr)) {
1386     ::uint32_t tag;
1387     ptr = ::_pbi::ReadTag(ptr, &tag);
1388     switch (tag >> 3) {
1389       // optional string name = 1;
1390       case 1:
1391         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1392           auto str = _internal_mutable_name();
1393           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1394           CHK_(ptr);
1395         } else {
1396           goto handle_unusual;
1397         }
1398         continue;
1399       // optional uint64 state = 2;
1400       case 2:
1401         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1402           _Internal::set_has_state(&has_bits);
1403           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1404           CHK_(ptr);
1405         } else {
1406           goto handle_unusual;
1407         }
1408         continue;
1409       // optional uint64 cpu_id = 3;
1410       case 3:
1411         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1412           _Internal::set_has_cpu_id(&has_bits);
1413           _impl_.cpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1414           CHK_(ptr);
1415         } else {
1416           goto handle_unusual;
1417         }
1418         continue;
1419       default:
1420         goto handle_unusual;
1421     }  // switch
1422   handle_unusual:
1423     if ((tag == 0) || ((tag & 7) == 4)) {
1424       CHK_(ptr);
1425       ctx->SetLastTag(tag);
1426       goto message_done;
1427     }
1428     ptr = UnknownFieldParse(
1429         tag,
1430         _internal_metadata_.mutable_unknown_fields<std::string>(),
1431         ptr, ctx);
1432     CHK_(ptr != nullptr);
1433   }  // while
1434 message_done:
1435   _impl_._has_bits_.Or(has_bits);
1436   return ptr;
1437 failure:
1438   ptr = nullptr;
1439   goto message_done;
1440 #undef CHK_
1441 }
1442 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1443 ::uint8_t* ClockDisableFtraceEvent::_InternalSerialize(
1444     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1445   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ClockDisableFtraceEvent)
1446   ::uint32_t cached_has_bits = 0;
1447   (void) cached_has_bits;
1448 
1449   cached_has_bits = _impl_._has_bits_[0];
1450   // optional string name = 1;
1451   if (cached_has_bits & 0x00000001u) {
1452     target = stream->WriteStringMaybeAliased(
1453         1, this->_internal_name(), target);
1454   }
1455 
1456   // optional uint64 state = 2;
1457   if (cached_has_bits & 0x00000002u) {
1458     target = stream->EnsureSpace(target);
1459     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_state(), target);
1460   }
1461 
1462   // optional uint64 cpu_id = 3;
1463   if (cached_has_bits & 0x00000004u) {
1464     target = stream->EnsureSpace(target);
1465     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_cpu_id(), target);
1466   }
1467 
1468   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1469     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1470         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1471   }
1472   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ClockDisableFtraceEvent)
1473   return target;
1474 }
1475 
ByteSizeLong() const1476 size_t ClockDisableFtraceEvent::ByteSizeLong() const {
1477 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ClockDisableFtraceEvent)
1478   size_t total_size = 0;
1479 
1480   ::uint32_t cached_has_bits = 0;
1481   // Prevent compiler warnings about cached_has_bits being unused
1482   (void) cached_has_bits;
1483 
1484   cached_has_bits = _impl_._has_bits_[0];
1485   if (cached_has_bits & 0x00000007u) {
1486     // optional string name = 1;
1487     if (cached_has_bits & 0x00000001u) {
1488       total_size += 1 +
1489         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1490           this->_internal_name());
1491     }
1492 
1493     // optional uint64 state = 2;
1494     if (cached_has_bits & 0x00000002u) {
1495       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_state());
1496     }
1497 
1498     // optional uint64 cpu_id = 3;
1499     if (cached_has_bits & 0x00000004u) {
1500       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cpu_id());
1501     }
1502 
1503   }
1504   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1505     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1506   }
1507   int cached_size = ::_pbi::ToCachedSize(total_size);
1508   SetCachedSize(cached_size);
1509   return total_size;
1510 }
1511 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1512 void ClockDisableFtraceEvent::CheckTypeAndMergeFrom(
1513     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1514   MergeFrom(*::_pbi::DownCast<const ClockDisableFtraceEvent*>(
1515       &from));
1516 }
1517 
MergeFrom(const ClockDisableFtraceEvent & from)1518 void ClockDisableFtraceEvent::MergeFrom(const ClockDisableFtraceEvent& from) {
1519   ClockDisableFtraceEvent* const _this = this;
1520   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ClockDisableFtraceEvent)
1521   GOOGLE_DCHECK_NE(&from, _this);
1522   ::uint32_t cached_has_bits = 0;
1523   (void) cached_has_bits;
1524 
1525   cached_has_bits = from._impl_._has_bits_[0];
1526   if (cached_has_bits & 0x00000007u) {
1527     if (cached_has_bits & 0x00000001u) {
1528       _this->_internal_set_name(from._internal_name());
1529     }
1530     if (cached_has_bits & 0x00000002u) {
1531       _this->_impl_.state_ = from._impl_.state_;
1532     }
1533     if (cached_has_bits & 0x00000004u) {
1534       _this->_impl_.cpu_id_ = from._impl_.cpu_id_;
1535     }
1536     _this->_impl_._has_bits_[0] |= cached_has_bits;
1537   }
1538   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1539 }
1540 
CopyFrom(const ClockDisableFtraceEvent & from)1541 void ClockDisableFtraceEvent::CopyFrom(const ClockDisableFtraceEvent& from) {
1542 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ClockDisableFtraceEvent)
1543   if (&from == this) return;
1544   Clear();
1545   MergeFrom(from);
1546 }
1547 
IsInitialized() const1548 bool ClockDisableFtraceEvent::IsInitialized() const {
1549   return true;
1550 }
1551 
InternalSwap(ClockDisableFtraceEvent * other)1552 void ClockDisableFtraceEvent::InternalSwap(ClockDisableFtraceEvent* other) {
1553   using std::swap;
1554   auto* lhs_arena = GetArenaForAllocation();
1555   auto* rhs_arena = other->GetArenaForAllocation();
1556   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1557   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1558   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1559       &_impl_.name_, lhs_arena,
1560       &other->_impl_.name_, rhs_arena
1561   );
1562   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1563       PROTOBUF_FIELD_OFFSET(ClockDisableFtraceEvent, _impl_.cpu_id_)
1564       + sizeof(ClockDisableFtraceEvent::_impl_.cpu_id_)  // NOLINT
1565       - PROTOBUF_FIELD_OFFSET(ClockDisableFtraceEvent, _impl_.state_)>(
1566           reinterpret_cast<char*>(&_impl_.state_),
1567           reinterpret_cast<char*>(&other->_impl_.state_));
1568 }
1569 
GetTypeName() const1570 std::string ClockDisableFtraceEvent::GetTypeName() const {
1571   return "perfetto.protos.ClockDisableFtraceEvent";
1572 }
1573 
1574 
1575 // ===================================================================
1576 
1577 class ClockSetRateFtraceEvent::_Internal {
1578  public:
1579   using HasBits = decltype(std::declval<ClockSetRateFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)1580   static void set_has_name(HasBits* has_bits) {
1581     (*has_bits)[0] |= 1u;
1582   }
set_has_state(HasBits * has_bits)1583   static void set_has_state(HasBits* has_bits) {
1584     (*has_bits)[0] |= 2u;
1585   }
set_has_cpu_id(HasBits * has_bits)1586   static void set_has_cpu_id(HasBits* has_bits) {
1587     (*has_bits)[0] |= 4u;
1588   }
1589 };
1590 
ClockSetRateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1591 ClockSetRateFtraceEvent::ClockSetRateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1592                          bool is_message_owned)
1593   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1594   SharedCtor(arena, is_message_owned);
1595   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ClockSetRateFtraceEvent)
1596 }
ClockSetRateFtraceEvent(const ClockSetRateFtraceEvent & from)1597 ClockSetRateFtraceEvent::ClockSetRateFtraceEvent(const ClockSetRateFtraceEvent& from)
1598   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1599   ClockSetRateFtraceEvent* const _this = this; (void)_this;
1600   new (&_impl_) Impl_{
1601       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1602     , /*decltype(_impl_._cached_size_)*/{}
1603     , decltype(_impl_.name_){}
1604     , decltype(_impl_.state_){}
1605     , decltype(_impl_.cpu_id_){}};
1606 
1607   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1608   _impl_.name_.InitDefault();
1609   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1610     _impl_.name_.Set("", GetArenaForAllocation());
1611   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1612   if (from._internal_has_name()) {
1613     _this->_impl_.name_.Set(from._internal_name(),
1614       _this->GetArenaForAllocation());
1615   }
1616   ::memcpy(&_impl_.state_, &from._impl_.state_,
1617     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.cpu_id_) -
1618     reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
1619   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ClockSetRateFtraceEvent)
1620 }
1621 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1622 inline void ClockSetRateFtraceEvent::SharedCtor(
1623     ::_pb::Arena* arena, bool is_message_owned) {
1624   (void)arena;
1625   (void)is_message_owned;
1626   new (&_impl_) Impl_{
1627       decltype(_impl_._has_bits_){}
1628     , /*decltype(_impl_._cached_size_)*/{}
1629     , decltype(_impl_.name_){}
1630     , decltype(_impl_.state_){::uint64_t{0u}}
1631     , decltype(_impl_.cpu_id_){::uint64_t{0u}}
1632   };
1633   _impl_.name_.InitDefault();
1634   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1635     _impl_.name_.Set("", GetArenaForAllocation());
1636   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1637 }
1638 
~ClockSetRateFtraceEvent()1639 ClockSetRateFtraceEvent::~ClockSetRateFtraceEvent() {
1640   // @@protoc_insertion_point(destructor:perfetto.protos.ClockSetRateFtraceEvent)
1641   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1642   (void)arena;
1643     return;
1644   }
1645   SharedDtor();
1646 }
1647 
SharedDtor()1648 inline void ClockSetRateFtraceEvent::SharedDtor() {
1649   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1650   _impl_.name_.Destroy();
1651 }
1652 
SetCachedSize(int size) const1653 void ClockSetRateFtraceEvent::SetCachedSize(int size) const {
1654   _impl_._cached_size_.Set(size);
1655 }
1656 
Clear()1657 void ClockSetRateFtraceEvent::Clear() {
1658 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ClockSetRateFtraceEvent)
1659   ::uint32_t cached_has_bits = 0;
1660   // Prevent compiler warnings about cached_has_bits being unused
1661   (void) cached_has_bits;
1662 
1663   cached_has_bits = _impl_._has_bits_[0];
1664   if (cached_has_bits & 0x00000001u) {
1665     _impl_.name_.ClearNonDefaultToEmpty();
1666   }
1667   if (cached_has_bits & 0x00000006u) {
1668     ::memset(&_impl_.state_, 0, static_cast<size_t>(
1669         reinterpret_cast<char*>(&_impl_.cpu_id_) -
1670         reinterpret_cast<char*>(&_impl_.state_)) + sizeof(_impl_.cpu_id_));
1671   }
1672   _impl_._has_bits_.Clear();
1673   _internal_metadata_.Clear<std::string>();
1674 }
1675 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1676 const char* ClockSetRateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1677 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1678   _Internal::HasBits has_bits{};
1679   while (!ctx->Done(&ptr)) {
1680     ::uint32_t tag;
1681     ptr = ::_pbi::ReadTag(ptr, &tag);
1682     switch (tag >> 3) {
1683       // optional string name = 1;
1684       case 1:
1685         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1686           auto str = _internal_mutable_name();
1687           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1688           CHK_(ptr);
1689         } else {
1690           goto handle_unusual;
1691         }
1692         continue;
1693       // optional uint64 state = 2;
1694       case 2:
1695         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1696           _Internal::set_has_state(&has_bits);
1697           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1698           CHK_(ptr);
1699         } else {
1700           goto handle_unusual;
1701         }
1702         continue;
1703       // optional uint64 cpu_id = 3;
1704       case 3:
1705         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1706           _Internal::set_has_cpu_id(&has_bits);
1707           _impl_.cpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1708           CHK_(ptr);
1709         } else {
1710           goto handle_unusual;
1711         }
1712         continue;
1713       default:
1714         goto handle_unusual;
1715     }  // switch
1716   handle_unusual:
1717     if ((tag == 0) || ((tag & 7) == 4)) {
1718       CHK_(ptr);
1719       ctx->SetLastTag(tag);
1720       goto message_done;
1721     }
1722     ptr = UnknownFieldParse(
1723         tag,
1724         _internal_metadata_.mutable_unknown_fields<std::string>(),
1725         ptr, ctx);
1726     CHK_(ptr != nullptr);
1727   }  // while
1728 message_done:
1729   _impl_._has_bits_.Or(has_bits);
1730   return ptr;
1731 failure:
1732   ptr = nullptr;
1733   goto message_done;
1734 #undef CHK_
1735 }
1736 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1737 ::uint8_t* ClockSetRateFtraceEvent::_InternalSerialize(
1738     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1739   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ClockSetRateFtraceEvent)
1740   ::uint32_t cached_has_bits = 0;
1741   (void) cached_has_bits;
1742 
1743   cached_has_bits = _impl_._has_bits_[0];
1744   // optional string name = 1;
1745   if (cached_has_bits & 0x00000001u) {
1746     target = stream->WriteStringMaybeAliased(
1747         1, this->_internal_name(), target);
1748   }
1749 
1750   // optional uint64 state = 2;
1751   if (cached_has_bits & 0x00000002u) {
1752     target = stream->EnsureSpace(target);
1753     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_state(), target);
1754   }
1755 
1756   // optional uint64 cpu_id = 3;
1757   if (cached_has_bits & 0x00000004u) {
1758     target = stream->EnsureSpace(target);
1759     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_cpu_id(), target);
1760   }
1761 
1762   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1763     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1764         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1765   }
1766   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ClockSetRateFtraceEvent)
1767   return target;
1768 }
1769 
ByteSizeLong() const1770 size_t ClockSetRateFtraceEvent::ByteSizeLong() const {
1771 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ClockSetRateFtraceEvent)
1772   size_t total_size = 0;
1773 
1774   ::uint32_t cached_has_bits = 0;
1775   // Prevent compiler warnings about cached_has_bits being unused
1776   (void) cached_has_bits;
1777 
1778   cached_has_bits = _impl_._has_bits_[0];
1779   if (cached_has_bits & 0x00000007u) {
1780     // optional string name = 1;
1781     if (cached_has_bits & 0x00000001u) {
1782       total_size += 1 +
1783         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1784           this->_internal_name());
1785     }
1786 
1787     // optional uint64 state = 2;
1788     if (cached_has_bits & 0x00000002u) {
1789       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_state());
1790     }
1791 
1792     // optional uint64 cpu_id = 3;
1793     if (cached_has_bits & 0x00000004u) {
1794       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cpu_id());
1795     }
1796 
1797   }
1798   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1799     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1800   }
1801   int cached_size = ::_pbi::ToCachedSize(total_size);
1802   SetCachedSize(cached_size);
1803   return total_size;
1804 }
1805 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1806 void ClockSetRateFtraceEvent::CheckTypeAndMergeFrom(
1807     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1808   MergeFrom(*::_pbi::DownCast<const ClockSetRateFtraceEvent*>(
1809       &from));
1810 }
1811 
MergeFrom(const ClockSetRateFtraceEvent & from)1812 void ClockSetRateFtraceEvent::MergeFrom(const ClockSetRateFtraceEvent& from) {
1813   ClockSetRateFtraceEvent* const _this = this;
1814   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ClockSetRateFtraceEvent)
1815   GOOGLE_DCHECK_NE(&from, _this);
1816   ::uint32_t cached_has_bits = 0;
1817   (void) cached_has_bits;
1818 
1819   cached_has_bits = from._impl_._has_bits_[0];
1820   if (cached_has_bits & 0x00000007u) {
1821     if (cached_has_bits & 0x00000001u) {
1822       _this->_internal_set_name(from._internal_name());
1823     }
1824     if (cached_has_bits & 0x00000002u) {
1825       _this->_impl_.state_ = from._impl_.state_;
1826     }
1827     if (cached_has_bits & 0x00000004u) {
1828       _this->_impl_.cpu_id_ = from._impl_.cpu_id_;
1829     }
1830     _this->_impl_._has_bits_[0] |= cached_has_bits;
1831   }
1832   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1833 }
1834 
CopyFrom(const ClockSetRateFtraceEvent & from)1835 void ClockSetRateFtraceEvent::CopyFrom(const ClockSetRateFtraceEvent& from) {
1836 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ClockSetRateFtraceEvent)
1837   if (&from == this) return;
1838   Clear();
1839   MergeFrom(from);
1840 }
1841 
IsInitialized() const1842 bool ClockSetRateFtraceEvent::IsInitialized() const {
1843   return true;
1844 }
1845 
InternalSwap(ClockSetRateFtraceEvent * other)1846 void ClockSetRateFtraceEvent::InternalSwap(ClockSetRateFtraceEvent* other) {
1847   using std::swap;
1848   auto* lhs_arena = GetArenaForAllocation();
1849   auto* rhs_arena = other->GetArenaForAllocation();
1850   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1851   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1852   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1853       &_impl_.name_, lhs_arena,
1854       &other->_impl_.name_, rhs_arena
1855   );
1856   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1857       PROTOBUF_FIELD_OFFSET(ClockSetRateFtraceEvent, _impl_.cpu_id_)
1858       + sizeof(ClockSetRateFtraceEvent::_impl_.cpu_id_)  // NOLINT
1859       - PROTOBUF_FIELD_OFFSET(ClockSetRateFtraceEvent, _impl_.state_)>(
1860           reinterpret_cast<char*>(&_impl_.state_),
1861           reinterpret_cast<char*>(&other->_impl_.state_));
1862 }
1863 
GetTypeName() const1864 std::string ClockSetRateFtraceEvent::GetTypeName() const {
1865   return "perfetto.protos.ClockSetRateFtraceEvent";
1866 }
1867 
1868 
1869 // ===================================================================
1870 
1871 class SuspendResumeFtraceEvent::_Internal {
1872  public:
1873   using HasBits = decltype(std::declval<SuspendResumeFtraceEvent>()._impl_._has_bits_);
set_has_action(HasBits * has_bits)1874   static void set_has_action(HasBits* has_bits) {
1875     (*has_bits)[0] |= 1u;
1876   }
set_has_val(HasBits * has_bits)1877   static void set_has_val(HasBits* has_bits) {
1878     (*has_bits)[0] |= 2u;
1879   }
set_has_start(HasBits * has_bits)1880   static void set_has_start(HasBits* has_bits) {
1881     (*has_bits)[0] |= 4u;
1882   }
1883 };
1884 
SuspendResumeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1885 SuspendResumeFtraceEvent::SuspendResumeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1886                          bool is_message_owned)
1887   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1888   SharedCtor(arena, is_message_owned);
1889   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SuspendResumeFtraceEvent)
1890 }
SuspendResumeFtraceEvent(const SuspendResumeFtraceEvent & from)1891 SuspendResumeFtraceEvent::SuspendResumeFtraceEvent(const SuspendResumeFtraceEvent& from)
1892   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1893   SuspendResumeFtraceEvent* const _this = this; (void)_this;
1894   new (&_impl_) Impl_{
1895       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1896     , /*decltype(_impl_._cached_size_)*/{}
1897     , decltype(_impl_.action_){}
1898     , decltype(_impl_.val_){}
1899     , decltype(_impl_.start_){}};
1900 
1901   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1902   _impl_.action_.InitDefault();
1903   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1904     _impl_.action_.Set("", GetArenaForAllocation());
1905   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1906   if (from._internal_has_action()) {
1907     _this->_impl_.action_.Set(from._internal_action(),
1908       _this->GetArenaForAllocation());
1909   }
1910   ::memcpy(&_impl_.val_, &from._impl_.val_,
1911     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.start_) -
1912     reinterpret_cast<char*>(&_impl_.val_)) + sizeof(_impl_.start_));
1913   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SuspendResumeFtraceEvent)
1914 }
1915 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1916 inline void SuspendResumeFtraceEvent::SharedCtor(
1917     ::_pb::Arena* arena, bool is_message_owned) {
1918   (void)arena;
1919   (void)is_message_owned;
1920   new (&_impl_) Impl_{
1921       decltype(_impl_._has_bits_){}
1922     , /*decltype(_impl_._cached_size_)*/{}
1923     , decltype(_impl_.action_){}
1924     , decltype(_impl_.val_){0}
1925     , decltype(_impl_.start_){0u}
1926   };
1927   _impl_.action_.InitDefault();
1928   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1929     _impl_.action_.Set("", GetArenaForAllocation());
1930   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1931 }
1932 
~SuspendResumeFtraceEvent()1933 SuspendResumeFtraceEvent::~SuspendResumeFtraceEvent() {
1934   // @@protoc_insertion_point(destructor:perfetto.protos.SuspendResumeFtraceEvent)
1935   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1936   (void)arena;
1937     return;
1938   }
1939   SharedDtor();
1940 }
1941 
SharedDtor()1942 inline void SuspendResumeFtraceEvent::SharedDtor() {
1943   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1944   _impl_.action_.Destroy();
1945 }
1946 
SetCachedSize(int size) const1947 void SuspendResumeFtraceEvent::SetCachedSize(int size) const {
1948   _impl_._cached_size_.Set(size);
1949 }
1950 
Clear()1951 void SuspendResumeFtraceEvent::Clear() {
1952 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SuspendResumeFtraceEvent)
1953   ::uint32_t cached_has_bits = 0;
1954   // Prevent compiler warnings about cached_has_bits being unused
1955   (void) cached_has_bits;
1956 
1957   cached_has_bits = _impl_._has_bits_[0];
1958   if (cached_has_bits & 0x00000001u) {
1959     _impl_.action_.ClearNonDefaultToEmpty();
1960   }
1961   if (cached_has_bits & 0x00000006u) {
1962     ::memset(&_impl_.val_, 0, static_cast<size_t>(
1963         reinterpret_cast<char*>(&_impl_.start_) -
1964         reinterpret_cast<char*>(&_impl_.val_)) + sizeof(_impl_.start_));
1965   }
1966   _impl_._has_bits_.Clear();
1967   _internal_metadata_.Clear<std::string>();
1968 }
1969 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1970 const char* SuspendResumeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1971 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1972   _Internal::HasBits has_bits{};
1973   while (!ctx->Done(&ptr)) {
1974     ::uint32_t tag;
1975     ptr = ::_pbi::ReadTag(ptr, &tag);
1976     switch (tag >> 3) {
1977       // optional string action = 1;
1978       case 1:
1979         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1980           auto str = _internal_mutable_action();
1981           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1982           CHK_(ptr);
1983         } else {
1984           goto handle_unusual;
1985         }
1986         continue;
1987       // optional int32 val = 2;
1988       case 2:
1989         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1990           _Internal::set_has_val(&has_bits);
1991           _impl_.val_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1992           CHK_(ptr);
1993         } else {
1994           goto handle_unusual;
1995         }
1996         continue;
1997       // optional uint32 start = 3;
1998       case 3:
1999         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2000           _Internal::set_has_start(&has_bits);
2001           _impl_.start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2002           CHK_(ptr);
2003         } else {
2004           goto handle_unusual;
2005         }
2006         continue;
2007       default:
2008         goto handle_unusual;
2009     }  // switch
2010   handle_unusual:
2011     if ((tag == 0) || ((tag & 7) == 4)) {
2012       CHK_(ptr);
2013       ctx->SetLastTag(tag);
2014       goto message_done;
2015     }
2016     ptr = UnknownFieldParse(
2017         tag,
2018         _internal_metadata_.mutable_unknown_fields<std::string>(),
2019         ptr, ctx);
2020     CHK_(ptr != nullptr);
2021   }  // while
2022 message_done:
2023   _impl_._has_bits_.Or(has_bits);
2024   return ptr;
2025 failure:
2026   ptr = nullptr;
2027   goto message_done;
2028 #undef CHK_
2029 }
2030 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2031 ::uint8_t* SuspendResumeFtraceEvent::_InternalSerialize(
2032     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2033   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SuspendResumeFtraceEvent)
2034   ::uint32_t cached_has_bits = 0;
2035   (void) cached_has_bits;
2036 
2037   cached_has_bits = _impl_._has_bits_[0];
2038   // optional string action = 1;
2039   if (cached_has_bits & 0x00000001u) {
2040     target = stream->WriteStringMaybeAliased(
2041         1, this->_internal_action(), target);
2042   }
2043 
2044   // optional int32 val = 2;
2045   if (cached_has_bits & 0x00000002u) {
2046     target = stream->EnsureSpace(target);
2047     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_val(), target);
2048   }
2049 
2050   // optional uint32 start = 3;
2051   if (cached_has_bits & 0x00000004u) {
2052     target = stream->EnsureSpace(target);
2053     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_start(), target);
2054   }
2055 
2056   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2057     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2058         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2059   }
2060   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SuspendResumeFtraceEvent)
2061   return target;
2062 }
2063 
ByteSizeLong() const2064 size_t SuspendResumeFtraceEvent::ByteSizeLong() const {
2065 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SuspendResumeFtraceEvent)
2066   size_t total_size = 0;
2067 
2068   ::uint32_t cached_has_bits = 0;
2069   // Prevent compiler warnings about cached_has_bits being unused
2070   (void) cached_has_bits;
2071 
2072   cached_has_bits = _impl_._has_bits_[0];
2073   if (cached_has_bits & 0x00000007u) {
2074     // optional string action = 1;
2075     if (cached_has_bits & 0x00000001u) {
2076       total_size += 1 +
2077         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2078           this->_internal_action());
2079     }
2080 
2081     // optional int32 val = 2;
2082     if (cached_has_bits & 0x00000002u) {
2083       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_val());
2084     }
2085 
2086     // optional uint32 start = 3;
2087     if (cached_has_bits & 0x00000004u) {
2088       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_start());
2089     }
2090 
2091   }
2092   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2093     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2094   }
2095   int cached_size = ::_pbi::ToCachedSize(total_size);
2096   SetCachedSize(cached_size);
2097   return total_size;
2098 }
2099 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2100 void SuspendResumeFtraceEvent::CheckTypeAndMergeFrom(
2101     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2102   MergeFrom(*::_pbi::DownCast<const SuspendResumeFtraceEvent*>(
2103       &from));
2104 }
2105 
MergeFrom(const SuspendResumeFtraceEvent & from)2106 void SuspendResumeFtraceEvent::MergeFrom(const SuspendResumeFtraceEvent& from) {
2107   SuspendResumeFtraceEvent* const _this = this;
2108   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SuspendResumeFtraceEvent)
2109   GOOGLE_DCHECK_NE(&from, _this);
2110   ::uint32_t cached_has_bits = 0;
2111   (void) cached_has_bits;
2112 
2113   cached_has_bits = from._impl_._has_bits_[0];
2114   if (cached_has_bits & 0x00000007u) {
2115     if (cached_has_bits & 0x00000001u) {
2116       _this->_internal_set_action(from._internal_action());
2117     }
2118     if (cached_has_bits & 0x00000002u) {
2119       _this->_impl_.val_ = from._impl_.val_;
2120     }
2121     if (cached_has_bits & 0x00000004u) {
2122       _this->_impl_.start_ = from._impl_.start_;
2123     }
2124     _this->_impl_._has_bits_[0] |= cached_has_bits;
2125   }
2126   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2127 }
2128 
CopyFrom(const SuspendResumeFtraceEvent & from)2129 void SuspendResumeFtraceEvent::CopyFrom(const SuspendResumeFtraceEvent& from) {
2130 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SuspendResumeFtraceEvent)
2131   if (&from == this) return;
2132   Clear();
2133   MergeFrom(from);
2134 }
2135 
IsInitialized() const2136 bool SuspendResumeFtraceEvent::IsInitialized() const {
2137   return true;
2138 }
2139 
InternalSwap(SuspendResumeFtraceEvent * other)2140 void SuspendResumeFtraceEvent::InternalSwap(SuspendResumeFtraceEvent* other) {
2141   using std::swap;
2142   auto* lhs_arena = GetArenaForAllocation();
2143   auto* rhs_arena = other->GetArenaForAllocation();
2144   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2145   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2146   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2147       &_impl_.action_, lhs_arena,
2148       &other->_impl_.action_, rhs_arena
2149   );
2150   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2151       PROTOBUF_FIELD_OFFSET(SuspendResumeFtraceEvent, _impl_.start_)
2152       + sizeof(SuspendResumeFtraceEvent::_impl_.start_)  // NOLINT
2153       - PROTOBUF_FIELD_OFFSET(SuspendResumeFtraceEvent, _impl_.val_)>(
2154           reinterpret_cast<char*>(&_impl_.val_),
2155           reinterpret_cast<char*>(&other->_impl_.val_));
2156 }
2157 
GetTypeName() const2158 std::string SuspendResumeFtraceEvent::GetTypeName() const {
2159   return "perfetto.protos.SuspendResumeFtraceEvent";
2160 }
2161 
2162 
2163 // ===================================================================
2164 
2165 class GpuFrequencyFtraceEvent::_Internal {
2166  public:
2167   using HasBits = decltype(std::declval<GpuFrequencyFtraceEvent>()._impl_._has_bits_);
set_has_gpu_id(HasBits * has_bits)2168   static void set_has_gpu_id(HasBits* has_bits) {
2169     (*has_bits)[0] |= 1u;
2170   }
set_has_state(HasBits * has_bits)2171   static void set_has_state(HasBits* has_bits) {
2172     (*has_bits)[0] |= 2u;
2173   }
2174 };
2175 
GpuFrequencyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2176 GpuFrequencyFtraceEvent::GpuFrequencyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2177                          bool is_message_owned)
2178   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2179   SharedCtor(arena, is_message_owned);
2180   // @@protoc_insertion_point(arena_constructor:perfetto.protos.GpuFrequencyFtraceEvent)
2181 }
GpuFrequencyFtraceEvent(const GpuFrequencyFtraceEvent & from)2182 GpuFrequencyFtraceEvent::GpuFrequencyFtraceEvent(const GpuFrequencyFtraceEvent& from)
2183   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2184   GpuFrequencyFtraceEvent* const _this = this; (void)_this;
2185   new (&_impl_) Impl_{
2186       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2187     , /*decltype(_impl_._cached_size_)*/{}
2188     , decltype(_impl_.gpu_id_){}
2189     , decltype(_impl_.state_){}};
2190 
2191   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2192   ::memcpy(&_impl_.gpu_id_, &from._impl_.gpu_id_,
2193     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.state_) -
2194     reinterpret_cast<char*>(&_impl_.gpu_id_)) + sizeof(_impl_.state_));
2195   // @@protoc_insertion_point(copy_constructor:perfetto.protos.GpuFrequencyFtraceEvent)
2196 }
2197 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2198 inline void GpuFrequencyFtraceEvent::SharedCtor(
2199     ::_pb::Arena* arena, bool is_message_owned) {
2200   (void)arena;
2201   (void)is_message_owned;
2202   new (&_impl_) Impl_{
2203       decltype(_impl_._has_bits_){}
2204     , /*decltype(_impl_._cached_size_)*/{}
2205     , decltype(_impl_.gpu_id_){0u}
2206     , decltype(_impl_.state_){0u}
2207   };
2208 }
2209 
~GpuFrequencyFtraceEvent()2210 GpuFrequencyFtraceEvent::~GpuFrequencyFtraceEvent() {
2211   // @@protoc_insertion_point(destructor:perfetto.protos.GpuFrequencyFtraceEvent)
2212   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2213   (void)arena;
2214     return;
2215   }
2216   SharedDtor();
2217 }
2218 
SharedDtor()2219 inline void GpuFrequencyFtraceEvent::SharedDtor() {
2220   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2221 }
2222 
SetCachedSize(int size) const2223 void GpuFrequencyFtraceEvent::SetCachedSize(int size) const {
2224   _impl_._cached_size_.Set(size);
2225 }
2226 
Clear()2227 void GpuFrequencyFtraceEvent::Clear() {
2228 // @@protoc_insertion_point(message_clear_start:perfetto.protos.GpuFrequencyFtraceEvent)
2229   ::uint32_t cached_has_bits = 0;
2230   // Prevent compiler warnings about cached_has_bits being unused
2231   (void) cached_has_bits;
2232 
2233   cached_has_bits = _impl_._has_bits_[0];
2234   if (cached_has_bits & 0x00000003u) {
2235     ::memset(&_impl_.gpu_id_, 0, static_cast<size_t>(
2236         reinterpret_cast<char*>(&_impl_.state_) -
2237         reinterpret_cast<char*>(&_impl_.gpu_id_)) + sizeof(_impl_.state_));
2238   }
2239   _impl_._has_bits_.Clear();
2240   _internal_metadata_.Clear<std::string>();
2241 }
2242 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2243 const char* GpuFrequencyFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2244 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2245   _Internal::HasBits has_bits{};
2246   while (!ctx->Done(&ptr)) {
2247     ::uint32_t tag;
2248     ptr = ::_pbi::ReadTag(ptr, &tag);
2249     switch (tag >> 3) {
2250       // optional uint32 gpu_id = 1;
2251       case 1:
2252         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2253           _Internal::set_has_gpu_id(&has_bits);
2254           _impl_.gpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2255           CHK_(ptr);
2256         } else {
2257           goto handle_unusual;
2258         }
2259         continue;
2260       // optional uint32 state = 2;
2261       case 2:
2262         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2263           _Internal::set_has_state(&has_bits);
2264           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2265           CHK_(ptr);
2266         } else {
2267           goto handle_unusual;
2268         }
2269         continue;
2270       default:
2271         goto handle_unusual;
2272     }  // switch
2273   handle_unusual:
2274     if ((tag == 0) || ((tag & 7) == 4)) {
2275       CHK_(ptr);
2276       ctx->SetLastTag(tag);
2277       goto message_done;
2278     }
2279     ptr = UnknownFieldParse(
2280         tag,
2281         _internal_metadata_.mutable_unknown_fields<std::string>(),
2282         ptr, ctx);
2283     CHK_(ptr != nullptr);
2284   }  // while
2285 message_done:
2286   _impl_._has_bits_.Or(has_bits);
2287   return ptr;
2288 failure:
2289   ptr = nullptr;
2290   goto message_done;
2291 #undef CHK_
2292 }
2293 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2294 ::uint8_t* GpuFrequencyFtraceEvent::_InternalSerialize(
2295     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2296   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.GpuFrequencyFtraceEvent)
2297   ::uint32_t cached_has_bits = 0;
2298   (void) cached_has_bits;
2299 
2300   cached_has_bits = _impl_._has_bits_[0];
2301   // optional uint32 gpu_id = 1;
2302   if (cached_has_bits & 0x00000001u) {
2303     target = stream->EnsureSpace(target);
2304     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_gpu_id(), target);
2305   }
2306 
2307   // optional uint32 state = 2;
2308   if (cached_has_bits & 0x00000002u) {
2309     target = stream->EnsureSpace(target);
2310     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_state(), target);
2311   }
2312 
2313   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2314     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2315         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2316   }
2317   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.GpuFrequencyFtraceEvent)
2318   return target;
2319 }
2320 
ByteSizeLong() const2321 size_t GpuFrequencyFtraceEvent::ByteSizeLong() const {
2322 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.GpuFrequencyFtraceEvent)
2323   size_t total_size = 0;
2324 
2325   ::uint32_t cached_has_bits = 0;
2326   // Prevent compiler warnings about cached_has_bits being unused
2327   (void) cached_has_bits;
2328 
2329   cached_has_bits = _impl_._has_bits_[0];
2330   if (cached_has_bits & 0x00000003u) {
2331     // optional uint32 gpu_id = 1;
2332     if (cached_has_bits & 0x00000001u) {
2333       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gpu_id());
2334     }
2335 
2336     // optional uint32 state = 2;
2337     if (cached_has_bits & 0x00000002u) {
2338       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_state());
2339     }
2340 
2341   }
2342   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2343     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2344   }
2345   int cached_size = ::_pbi::ToCachedSize(total_size);
2346   SetCachedSize(cached_size);
2347   return total_size;
2348 }
2349 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2350 void GpuFrequencyFtraceEvent::CheckTypeAndMergeFrom(
2351     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2352   MergeFrom(*::_pbi::DownCast<const GpuFrequencyFtraceEvent*>(
2353       &from));
2354 }
2355 
MergeFrom(const GpuFrequencyFtraceEvent & from)2356 void GpuFrequencyFtraceEvent::MergeFrom(const GpuFrequencyFtraceEvent& from) {
2357   GpuFrequencyFtraceEvent* const _this = this;
2358   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.GpuFrequencyFtraceEvent)
2359   GOOGLE_DCHECK_NE(&from, _this);
2360   ::uint32_t cached_has_bits = 0;
2361   (void) cached_has_bits;
2362 
2363   cached_has_bits = from._impl_._has_bits_[0];
2364   if (cached_has_bits & 0x00000003u) {
2365     if (cached_has_bits & 0x00000001u) {
2366       _this->_impl_.gpu_id_ = from._impl_.gpu_id_;
2367     }
2368     if (cached_has_bits & 0x00000002u) {
2369       _this->_impl_.state_ = from._impl_.state_;
2370     }
2371     _this->_impl_._has_bits_[0] |= cached_has_bits;
2372   }
2373   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2374 }
2375 
CopyFrom(const GpuFrequencyFtraceEvent & from)2376 void GpuFrequencyFtraceEvent::CopyFrom(const GpuFrequencyFtraceEvent& from) {
2377 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.GpuFrequencyFtraceEvent)
2378   if (&from == this) return;
2379   Clear();
2380   MergeFrom(from);
2381 }
2382 
IsInitialized() const2383 bool GpuFrequencyFtraceEvent::IsInitialized() const {
2384   return true;
2385 }
2386 
InternalSwap(GpuFrequencyFtraceEvent * other)2387 void GpuFrequencyFtraceEvent::InternalSwap(GpuFrequencyFtraceEvent* other) {
2388   using std::swap;
2389   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2390   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2391   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2392       PROTOBUF_FIELD_OFFSET(GpuFrequencyFtraceEvent, _impl_.state_)
2393       + sizeof(GpuFrequencyFtraceEvent::_impl_.state_)  // NOLINT
2394       - PROTOBUF_FIELD_OFFSET(GpuFrequencyFtraceEvent, _impl_.gpu_id_)>(
2395           reinterpret_cast<char*>(&_impl_.gpu_id_),
2396           reinterpret_cast<char*>(&other->_impl_.gpu_id_));
2397 }
2398 
GetTypeName() const2399 std::string GpuFrequencyFtraceEvent::GetTypeName() const {
2400   return "perfetto.protos.GpuFrequencyFtraceEvent";
2401 }
2402 
2403 
2404 // ===================================================================
2405 
2406 class WakeupSourceActivateFtraceEvent::_Internal {
2407  public:
2408   using HasBits = decltype(std::declval<WakeupSourceActivateFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)2409   static void set_has_name(HasBits* has_bits) {
2410     (*has_bits)[0] |= 1u;
2411   }
set_has_state(HasBits * has_bits)2412   static void set_has_state(HasBits* has_bits) {
2413     (*has_bits)[0] |= 2u;
2414   }
2415 };
2416 
WakeupSourceActivateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2417 WakeupSourceActivateFtraceEvent::WakeupSourceActivateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2418                          bool is_message_owned)
2419   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2420   SharedCtor(arena, is_message_owned);
2421   // @@protoc_insertion_point(arena_constructor:perfetto.protos.WakeupSourceActivateFtraceEvent)
2422 }
WakeupSourceActivateFtraceEvent(const WakeupSourceActivateFtraceEvent & from)2423 WakeupSourceActivateFtraceEvent::WakeupSourceActivateFtraceEvent(const WakeupSourceActivateFtraceEvent& from)
2424   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2425   WakeupSourceActivateFtraceEvent* const _this = this; (void)_this;
2426   new (&_impl_) Impl_{
2427       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2428     , /*decltype(_impl_._cached_size_)*/{}
2429     , decltype(_impl_.name_){}
2430     , decltype(_impl_.state_){}};
2431 
2432   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2433   _impl_.name_.InitDefault();
2434   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2435     _impl_.name_.Set("", GetArenaForAllocation());
2436   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2437   if (from._internal_has_name()) {
2438     _this->_impl_.name_.Set(from._internal_name(),
2439       _this->GetArenaForAllocation());
2440   }
2441   _this->_impl_.state_ = from._impl_.state_;
2442   // @@protoc_insertion_point(copy_constructor:perfetto.protos.WakeupSourceActivateFtraceEvent)
2443 }
2444 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2445 inline void WakeupSourceActivateFtraceEvent::SharedCtor(
2446     ::_pb::Arena* arena, bool is_message_owned) {
2447   (void)arena;
2448   (void)is_message_owned;
2449   new (&_impl_) Impl_{
2450       decltype(_impl_._has_bits_){}
2451     , /*decltype(_impl_._cached_size_)*/{}
2452     , decltype(_impl_.name_){}
2453     , decltype(_impl_.state_){::uint64_t{0u}}
2454   };
2455   _impl_.name_.InitDefault();
2456   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2457     _impl_.name_.Set("", GetArenaForAllocation());
2458   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2459 }
2460 
~WakeupSourceActivateFtraceEvent()2461 WakeupSourceActivateFtraceEvent::~WakeupSourceActivateFtraceEvent() {
2462   // @@protoc_insertion_point(destructor:perfetto.protos.WakeupSourceActivateFtraceEvent)
2463   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2464   (void)arena;
2465     return;
2466   }
2467   SharedDtor();
2468 }
2469 
SharedDtor()2470 inline void WakeupSourceActivateFtraceEvent::SharedDtor() {
2471   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2472   _impl_.name_.Destroy();
2473 }
2474 
SetCachedSize(int size) const2475 void WakeupSourceActivateFtraceEvent::SetCachedSize(int size) const {
2476   _impl_._cached_size_.Set(size);
2477 }
2478 
Clear()2479 void WakeupSourceActivateFtraceEvent::Clear() {
2480 // @@protoc_insertion_point(message_clear_start:perfetto.protos.WakeupSourceActivateFtraceEvent)
2481   ::uint32_t cached_has_bits = 0;
2482   // Prevent compiler warnings about cached_has_bits being unused
2483   (void) cached_has_bits;
2484 
2485   cached_has_bits = _impl_._has_bits_[0];
2486   if (cached_has_bits & 0x00000001u) {
2487     _impl_.name_.ClearNonDefaultToEmpty();
2488   }
2489   _impl_.state_ = ::uint64_t{0u};
2490   _impl_._has_bits_.Clear();
2491   _internal_metadata_.Clear<std::string>();
2492 }
2493 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2494 const char* WakeupSourceActivateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2495 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2496   _Internal::HasBits has_bits{};
2497   while (!ctx->Done(&ptr)) {
2498     ::uint32_t tag;
2499     ptr = ::_pbi::ReadTag(ptr, &tag);
2500     switch (tag >> 3) {
2501       // optional string name = 1;
2502       case 1:
2503         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2504           auto str = _internal_mutable_name();
2505           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2506           CHK_(ptr);
2507         } else {
2508           goto handle_unusual;
2509         }
2510         continue;
2511       // optional uint64 state = 2;
2512       case 2:
2513         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2514           _Internal::set_has_state(&has_bits);
2515           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2516           CHK_(ptr);
2517         } else {
2518           goto handle_unusual;
2519         }
2520         continue;
2521       default:
2522         goto handle_unusual;
2523     }  // switch
2524   handle_unusual:
2525     if ((tag == 0) || ((tag & 7) == 4)) {
2526       CHK_(ptr);
2527       ctx->SetLastTag(tag);
2528       goto message_done;
2529     }
2530     ptr = UnknownFieldParse(
2531         tag,
2532         _internal_metadata_.mutable_unknown_fields<std::string>(),
2533         ptr, ctx);
2534     CHK_(ptr != nullptr);
2535   }  // while
2536 message_done:
2537   _impl_._has_bits_.Or(has_bits);
2538   return ptr;
2539 failure:
2540   ptr = nullptr;
2541   goto message_done;
2542 #undef CHK_
2543 }
2544 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2545 ::uint8_t* WakeupSourceActivateFtraceEvent::_InternalSerialize(
2546     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2547   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.WakeupSourceActivateFtraceEvent)
2548   ::uint32_t cached_has_bits = 0;
2549   (void) cached_has_bits;
2550 
2551   cached_has_bits = _impl_._has_bits_[0];
2552   // optional string name = 1;
2553   if (cached_has_bits & 0x00000001u) {
2554     target = stream->WriteStringMaybeAliased(
2555         1, this->_internal_name(), target);
2556   }
2557 
2558   // optional uint64 state = 2;
2559   if (cached_has_bits & 0x00000002u) {
2560     target = stream->EnsureSpace(target);
2561     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_state(), target);
2562   }
2563 
2564   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2565     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2566         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2567   }
2568   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.WakeupSourceActivateFtraceEvent)
2569   return target;
2570 }
2571 
ByteSizeLong() const2572 size_t WakeupSourceActivateFtraceEvent::ByteSizeLong() const {
2573 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.WakeupSourceActivateFtraceEvent)
2574   size_t total_size = 0;
2575 
2576   ::uint32_t cached_has_bits = 0;
2577   // Prevent compiler warnings about cached_has_bits being unused
2578   (void) cached_has_bits;
2579 
2580   cached_has_bits = _impl_._has_bits_[0];
2581   if (cached_has_bits & 0x00000003u) {
2582     // optional string name = 1;
2583     if (cached_has_bits & 0x00000001u) {
2584       total_size += 1 +
2585         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2586           this->_internal_name());
2587     }
2588 
2589     // optional uint64 state = 2;
2590     if (cached_has_bits & 0x00000002u) {
2591       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_state());
2592     }
2593 
2594   }
2595   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2596     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2597   }
2598   int cached_size = ::_pbi::ToCachedSize(total_size);
2599   SetCachedSize(cached_size);
2600   return total_size;
2601 }
2602 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2603 void WakeupSourceActivateFtraceEvent::CheckTypeAndMergeFrom(
2604     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2605   MergeFrom(*::_pbi::DownCast<const WakeupSourceActivateFtraceEvent*>(
2606       &from));
2607 }
2608 
MergeFrom(const WakeupSourceActivateFtraceEvent & from)2609 void WakeupSourceActivateFtraceEvent::MergeFrom(const WakeupSourceActivateFtraceEvent& from) {
2610   WakeupSourceActivateFtraceEvent* const _this = this;
2611   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.WakeupSourceActivateFtraceEvent)
2612   GOOGLE_DCHECK_NE(&from, _this);
2613   ::uint32_t cached_has_bits = 0;
2614   (void) cached_has_bits;
2615 
2616   cached_has_bits = from._impl_._has_bits_[0];
2617   if (cached_has_bits & 0x00000003u) {
2618     if (cached_has_bits & 0x00000001u) {
2619       _this->_internal_set_name(from._internal_name());
2620     }
2621     if (cached_has_bits & 0x00000002u) {
2622       _this->_impl_.state_ = from._impl_.state_;
2623     }
2624     _this->_impl_._has_bits_[0] |= cached_has_bits;
2625   }
2626   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2627 }
2628 
CopyFrom(const WakeupSourceActivateFtraceEvent & from)2629 void WakeupSourceActivateFtraceEvent::CopyFrom(const WakeupSourceActivateFtraceEvent& from) {
2630 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.WakeupSourceActivateFtraceEvent)
2631   if (&from == this) return;
2632   Clear();
2633   MergeFrom(from);
2634 }
2635 
IsInitialized() const2636 bool WakeupSourceActivateFtraceEvent::IsInitialized() const {
2637   return true;
2638 }
2639 
InternalSwap(WakeupSourceActivateFtraceEvent * other)2640 void WakeupSourceActivateFtraceEvent::InternalSwap(WakeupSourceActivateFtraceEvent* other) {
2641   using std::swap;
2642   auto* lhs_arena = GetArenaForAllocation();
2643   auto* rhs_arena = other->GetArenaForAllocation();
2644   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2645   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2646   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2647       &_impl_.name_, lhs_arena,
2648       &other->_impl_.name_, rhs_arena
2649   );
2650   swap(_impl_.state_, other->_impl_.state_);
2651 }
2652 
GetTypeName() const2653 std::string WakeupSourceActivateFtraceEvent::GetTypeName() const {
2654   return "perfetto.protos.WakeupSourceActivateFtraceEvent";
2655 }
2656 
2657 
2658 // ===================================================================
2659 
2660 class WakeupSourceDeactivateFtraceEvent::_Internal {
2661  public:
2662   using HasBits = decltype(std::declval<WakeupSourceDeactivateFtraceEvent>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)2663   static void set_has_name(HasBits* has_bits) {
2664     (*has_bits)[0] |= 1u;
2665   }
set_has_state(HasBits * has_bits)2666   static void set_has_state(HasBits* has_bits) {
2667     (*has_bits)[0] |= 2u;
2668   }
2669 };
2670 
WakeupSourceDeactivateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2671 WakeupSourceDeactivateFtraceEvent::WakeupSourceDeactivateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2672                          bool is_message_owned)
2673   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2674   SharedCtor(arena, is_message_owned);
2675   // @@protoc_insertion_point(arena_constructor:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2676 }
WakeupSourceDeactivateFtraceEvent(const WakeupSourceDeactivateFtraceEvent & from)2677 WakeupSourceDeactivateFtraceEvent::WakeupSourceDeactivateFtraceEvent(const WakeupSourceDeactivateFtraceEvent& from)
2678   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2679   WakeupSourceDeactivateFtraceEvent* const _this = this; (void)_this;
2680   new (&_impl_) Impl_{
2681       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2682     , /*decltype(_impl_._cached_size_)*/{}
2683     , decltype(_impl_.name_){}
2684     , decltype(_impl_.state_){}};
2685 
2686   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2687   _impl_.name_.InitDefault();
2688   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2689     _impl_.name_.Set("", GetArenaForAllocation());
2690   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2691   if (from._internal_has_name()) {
2692     _this->_impl_.name_.Set(from._internal_name(),
2693       _this->GetArenaForAllocation());
2694   }
2695   _this->_impl_.state_ = from._impl_.state_;
2696   // @@protoc_insertion_point(copy_constructor:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2697 }
2698 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2699 inline void WakeupSourceDeactivateFtraceEvent::SharedCtor(
2700     ::_pb::Arena* arena, bool is_message_owned) {
2701   (void)arena;
2702   (void)is_message_owned;
2703   new (&_impl_) Impl_{
2704       decltype(_impl_._has_bits_){}
2705     , /*decltype(_impl_._cached_size_)*/{}
2706     , decltype(_impl_.name_){}
2707     , decltype(_impl_.state_){::uint64_t{0u}}
2708   };
2709   _impl_.name_.InitDefault();
2710   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2711     _impl_.name_.Set("", GetArenaForAllocation());
2712   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2713 }
2714 
~WakeupSourceDeactivateFtraceEvent()2715 WakeupSourceDeactivateFtraceEvent::~WakeupSourceDeactivateFtraceEvent() {
2716   // @@protoc_insertion_point(destructor:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2717   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2718   (void)arena;
2719     return;
2720   }
2721   SharedDtor();
2722 }
2723 
SharedDtor()2724 inline void WakeupSourceDeactivateFtraceEvent::SharedDtor() {
2725   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2726   _impl_.name_.Destroy();
2727 }
2728 
SetCachedSize(int size) const2729 void WakeupSourceDeactivateFtraceEvent::SetCachedSize(int size) const {
2730   _impl_._cached_size_.Set(size);
2731 }
2732 
Clear()2733 void WakeupSourceDeactivateFtraceEvent::Clear() {
2734 // @@protoc_insertion_point(message_clear_start:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2735   ::uint32_t cached_has_bits = 0;
2736   // Prevent compiler warnings about cached_has_bits being unused
2737   (void) cached_has_bits;
2738 
2739   cached_has_bits = _impl_._has_bits_[0];
2740   if (cached_has_bits & 0x00000001u) {
2741     _impl_.name_.ClearNonDefaultToEmpty();
2742   }
2743   _impl_.state_ = ::uint64_t{0u};
2744   _impl_._has_bits_.Clear();
2745   _internal_metadata_.Clear<std::string>();
2746 }
2747 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2748 const char* WakeupSourceDeactivateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2749 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2750   _Internal::HasBits has_bits{};
2751   while (!ctx->Done(&ptr)) {
2752     ::uint32_t tag;
2753     ptr = ::_pbi::ReadTag(ptr, &tag);
2754     switch (tag >> 3) {
2755       // optional string name = 1;
2756       case 1:
2757         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2758           auto str = _internal_mutable_name();
2759           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2760           CHK_(ptr);
2761         } else {
2762           goto handle_unusual;
2763         }
2764         continue;
2765       // optional uint64 state = 2;
2766       case 2:
2767         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2768           _Internal::set_has_state(&has_bits);
2769           _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2770           CHK_(ptr);
2771         } else {
2772           goto handle_unusual;
2773         }
2774         continue;
2775       default:
2776         goto handle_unusual;
2777     }  // switch
2778   handle_unusual:
2779     if ((tag == 0) || ((tag & 7) == 4)) {
2780       CHK_(ptr);
2781       ctx->SetLastTag(tag);
2782       goto message_done;
2783     }
2784     ptr = UnknownFieldParse(
2785         tag,
2786         _internal_metadata_.mutable_unknown_fields<std::string>(),
2787         ptr, ctx);
2788     CHK_(ptr != nullptr);
2789   }  // while
2790 message_done:
2791   _impl_._has_bits_.Or(has_bits);
2792   return ptr;
2793 failure:
2794   ptr = nullptr;
2795   goto message_done;
2796 #undef CHK_
2797 }
2798 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2799 ::uint8_t* WakeupSourceDeactivateFtraceEvent::_InternalSerialize(
2800     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2801   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2802   ::uint32_t cached_has_bits = 0;
2803   (void) cached_has_bits;
2804 
2805   cached_has_bits = _impl_._has_bits_[0];
2806   // optional string name = 1;
2807   if (cached_has_bits & 0x00000001u) {
2808     target = stream->WriteStringMaybeAliased(
2809         1, this->_internal_name(), target);
2810   }
2811 
2812   // optional uint64 state = 2;
2813   if (cached_has_bits & 0x00000002u) {
2814     target = stream->EnsureSpace(target);
2815     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_state(), target);
2816   }
2817 
2818   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2819     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2820         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2821   }
2822   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2823   return target;
2824 }
2825 
ByteSizeLong() const2826 size_t WakeupSourceDeactivateFtraceEvent::ByteSizeLong() const {
2827 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2828   size_t total_size = 0;
2829 
2830   ::uint32_t cached_has_bits = 0;
2831   // Prevent compiler warnings about cached_has_bits being unused
2832   (void) cached_has_bits;
2833 
2834   cached_has_bits = _impl_._has_bits_[0];
2835   if (cached_has_bits & 0x00000003u) {
2836     // optional string name = 1;
2837     if (cached_has_bits & 0x00000001u) {
2838       total_size += 1 +
2839         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2840           this->_internal_name());
2841     }
2842 
2843     // optional uint64 state = 2;
2844     if (cached_has_bits & 0x00000002u) {
2845       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_state());
2846     }
2847 
2848   }
2849   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2850     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2851   }
2852   int cached_size = ::_pbi::ToCachedSize(total_size);
2853   SetCachedSize(cached_size);
2854   return total_size;
2855 }
2856 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2857 void WakeupSourceDeactivateFtraceEvent::CheckTypeAndMergeFrom(
2858     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2859   MergeFrom(*::_pbi::DownCast<const WakeupSourceDeactivateFtraceEvent*>(
2860       &from));
2861 }
2862 
MergeFrom(const WakeupSourceDeactivateFtraceEvent & from)2863 void WakeupSourceDeactivateFtraceEvent::MergeFrom(const WakeupSourceDeactivateFtraceEvent& from) {
2864   WakeupSourceDeactivateFtraceEvent* const _this = this;
2865   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2866   GOOGLE_DCHECK_NE(&from, _this);
2867   ::uint32_t cached_has_bits = 0;
2868   (void) cached_has_bits;
2869 
2870   cached_has_bits = from._impl_._has_bits_[0];
2871   if (cached_has_bits & 0x00000003u) {
2872     if (cached_has_bits & 0x00000001u) {
2873       _this->_internal_set_name(from._internal_name());
2874     }
2875     if (cached_has_bits & 0x00000002u) {
2876       _this->_impl_.state_ = from._impl_.state_;
2877     }
2878     _this->_impl_._has_bits_[0] |= cached_has_bits;
2879   }
2880   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2881 }
2882 
CopyFrom(const WakeupSourceDeactivateFtraceEvent & from)2883 void WakeupSourceDeactivateFtraceEvent::CopyFrom(const WakeupSourceDeactivateFtraceEvent& from) {
2884 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.WakeupSourceDeactivateFtraceEvent)
2885   if (&from == this) return;
2886   Clear();
2887   MergeFrom(from);
2888 }
2889 
IsInitialized() const2890 bool WakeupSourceDeactivateFtraceEvent::IsInitialized() const {
2891   return true;
2892 }
2893 
InternalSwap(WakeupSourceDeactivateFtraceEvent * other)2894 void WakeupSourceDeactivateFtraceEvent::InternalSwap(WakeupSourceDeactivateFtraceEvent* other) {
2895   using std::swap;
2896   auto* lhs_arena = GetArenaForAllocation();
2897   auto* rhs_arena = other->GetArenaForAllocation();
2898   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2899   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2900   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2901       &_impl_.name_, lhs_arena,
2902       &other->_impl_.name_, rhs_arena
2903   );
2904   swap(_impl_.state_, other->_impl_.state_);
2905 }
2906 
GetTypeName() const2907 std::string WakeupSourceDeactivateFtraceEvent::GetTypeName() const {
2908   return "perfetto.protos.WakeupSourceDeactivateFtraceEvent";
2909 }
2910 
2911 
2912 // ===================================================================
2913 
2914 class GpuWorkPeriodFtraceEvent::_Internal {
2915  public:
2916   using HasBits = decltype(std::declval<GpuWorkPeriodFtraceEvent>()._impl_._has_bits_);
set_has_gpu_id(HasBits * has_bits)2917   static void set_has_gpu_id(HasBits* has_bits) {
2918     (*has_bits)[0] |= 1u;
2919   }
set_has_uid(HasBits * has_bits)2920   static void set_has_uid(HasBits* has_bits) {
2921     (*has_bits)[0] |= 2u;
2922   }
set_has_start_time_ns(HasBits * has_bits)2923   static void set_has_start_time_ns(HasBits* has_bits) {
2924     (*has_bits)[0] |= 4u;
2925   }
set_has_end_time_ns(HasBits * has_bits)2926   static void set_has_end_time_ns(HasBits* has_bits) {
2927     (*has_bits)[0] |= 8u;
2928   }
set_has_total_active_duration_ns(HasBits * has_bits)2929   static void set_has_total_active_duration_ns(HasBits* has_bits) {
2930     (*has_bits)[0] |= 16u;
2931   }
2932 };
2933 
GpuWorkPeriodFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2934 GpuWorkPeriodFtraceEvent::GpuWorkPeriodFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2935                          bool is_message_owned)
2936   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2937   SharedCtor(arena, is_message_owned);
2938   // @@protoc_insertion_point(arena_constructor:perfetto.protos.GpuWorkPeriodFtraceEvent)
2939 }
GpuWorkPeriodFtraceEvent(const GpuWorkPeriodFtraceEvent & from)2940 GpuWorkPeriodFtraceEvent::GpuWorkPeriodFtraceEvent(const GpuWorkPeriodFtraceEvent& from)
2941   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2942   GpuWorkPeriodFtraceEvent* const _this = this; (void)_this;
2943   new (&_impl_) Impl_{
2944       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2945     , /*decltype(_impl_._cached_size_)*/{}
2946     , decltype(_impl_.gpu_id_){}
2947     , decltype(_impl_.uid_){}
2948     , decltype(_impl_.start_time_ns_){}
2949     , decltype(_impl_.end_time_ns_){}
2950     , decltype(_impl_.total_active_duration_ns_){}};
2951 
2952   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2953   ::memcpy(&_impl_.gpu_id_, &from._impl_.gpu_id_,
2954     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.total_active_duration_ns_) -
2955     reinterpret_cast<char*>(&_impl_.gpu_id_)) + sizeof(_impl_.total_active_duration_ns_));
2956   // @@protoc_insertion_point(copy_constructor:perfetto.protos.GpuWorkPeriodFtraceEvent)
2957 }
2958 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2959 inline void GpuWorkPeriodFtraceEvent::SharedCtor(
2960     ::_pb::Arena* arena, bool is_message_owned) {
2961   (void)arena;
2962   (void)is_message_owned;
2963   new (&_impl_) Impl_{
2964       decltype(_impl_._has_bits_){}
2965     , /*decltype(_impl_._cached_size_)*/{}
2966     , decltype(_impl_.gpu_id_){0u}
2967     , decltype(_impl_.uid_){0u}
2968     , decltype(_impl_.start_time_ns_){::uint64_t{0u}}
2969     , decltype(_impl_.end_time_ns_){::uint64_t{0u}}
2970     , decltype(_impl_.total_active_duration_ns_){::uint64_t{0u}}
2971   };
2972 }
2973 
~GpuWorkPeriodFtraceEvent()2974 GpuWorkPeriodFtraceEvent::~GpuWorkPeriodFtraceEvent() {
2975   // @@protoc_insertion_point(destructor:perfetto.protos.GpuWorkPeriodFtraceEvent)
2976   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2977   (void)arena;
2978     return;
2979   }
2980   SharedDtor();
2981 }
2982 
SharedDtor()2983 inline void GpuWorkPeriodFtraceEvent::SharedDtor() {
2984   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2985 }
2986 
SetCachedSize(int size) const2987 void GpuWorkPeriodFtraceEvent::SetCachedSize(int size) const {
2988   _impl_._cached_size_.Set(size);
2989 }
2990 
Clear()2991 void GpuWorkPeriodFtraceEvent::Clear() {
2992 // @@protoc_insertion_point(message_clear_start:perfetto.protos.GpuWorkPeriodFtraceEvent)
2993   ::uint32_t cached_has_bits = 0;
2994   // Prevent compiler warnings about cached_has_bits being unused
2995   (void) cached_has_bits;
2996 
2997   cached_has_bits = _impl_._has_bits_[0];
2998   if (cached_has_bits & 0x0000001fu) {
2999     ::memset(&_impl_.gpu_id_, 0, static_cast<size_t>(
3000         reinterpret_cast<char*>(&_impl_.total_active_duration_ns_) -
3001         reinterpret_cast<char*>(&_impl_.gpu_id_)) + sizeof(_impl_.total_active_duration_ns_));
3002   }
3003   _impl_._has_bits_.Clear();
3004   _internal_metadata_.Clear<std::string>();
3005 }
3006 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3007 const char* GpuWorkPeriodFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3008 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3009   _Internal::HasBits has_bits{};
3010   while (!ctx->Done(&ptr)) {
3011     ::uint32_t tag;
3012     ptr = ::_pbi::ReadTag(ptr, &tag);
3013     switch (tag >> 3) {
3014       // optional uint32 gpu_id = 1;
3015       case 1:
3016         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3017           _Internal::set_has_gpu_id(&has_bits);
3018           _impl_.gpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3019           CHK_(ptr);
3020         } else {
3021           goto handle_unusual;
3022         }
3023         continue;
3024       // optional uint32 uid = 2;
3025       case 2:
3026         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3027           _Internal::set_has_uid(&has_bits);
3028           _impl_.uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3029           CHK_(ptr);
3030         } else {
3031           goto handle_unusual;
3032         }
3033         continue;
3034       // optional uint64 start_time_ns = 3;
3035       case 3:
3036         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3037           _Internal::set_has_start_time_ns(&has_bits);
3038           _impl_.start_time_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3039           CHK_(ptr);
3040         } else {
3041           goto handle_unusual;
3042         }
3043         continue;
3044       // optional uint64 end_time_ns = 4;
3045       case 4:
3046         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3047           _Internal::set_has_end_time_ns(&has_bits);
3048           _impl_.end_time_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3049           CHK_(ptr);
3050         } else {
3051           goto handle_unusual;
3052         }
3053         continue;
3054       // optional uint64 total_active_duration_ns = 5;
3055       case 5:
3056         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3057           _Internal::set_has_total_active_duration_ns(&has_bits);
3058           _impl_.total_active_duration_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3059           CHK_(ptr);
3060         } else {
3061           goto handle_unusual;
3062         }
3063         continue;
3064       default:
3065         goto handle_unusual;
3066     }  // switch
3067   handle_unusual:
3068     if ((tag == 0) || ((tag & 7) == 4)) {
3069       CHK_(ptr);
3070       ctx->SetLastTag(tag);
3071       goto message_done;
3072     }
3073     ptr = UnknownFieldParse(
3074         tag,
3075         _internal_metadata_.mutable_unknown_fields<std::string>(),
3076         ptr, ctx);
3077     CHK_(ptr != nullptr);
3078   }  // while
3079 message_done:
3080   _impl_._has_bits_.Or(has_bits);
3081   return ptr;
3082 failure:
3083   ptr = nullptr;
3084   goto message_done;
3085 #undef CHK_
3086 }
3087 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3088 ::uint8_t* GpuWorkPeriodFtraceEvent::_InternalSerialize(
3089     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3090   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.GpuWorkPeriodFtraceEvent)
3091   ::uint32_t cached_has_bits = 0;
3092   (void) cached_has_bits;
3093 
3094   cached_has_bits = _impl_._has_bits_[0];
3095   // optional uint32 gpu_id = 1;
3096   if (cached_has_bits & 0x00000001u) {
3097     target = stream->EnsureSpace(target);
3098     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_gpu_id(), target);
3099   }
3100 
3101   // optional uint32 uid = 2;
3102   if (cached_has_bits & 0x00000002u) {
3103     target = stream->EnsureSpace(target);
3104     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_uid(), target);
3105   }
3106 
3107   // optional uint64 start_time_ns = 3;
3108   if (cached_has_bits & 0x00000004u) {
3109     target = stream->EnsureSpace(target);
3110     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_start_time_ns(), target);
3111   }
3112 
3113   // optional uint64 end_time_ns = 4;
3114   if (cached_has_bits & 0x00000008u) {
3115     target = stream->EnsureSpace(target);
3116     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_end_time_ns(), target);
3117   }
3118 
3119   // optional uint64 total_active_duration_ns = 5;
3120   if (cached_has_bits & 0x00000010u) {
3121     target = stream->EnsureSpace(target);
3122     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_total_active_duration_ns(), target);
3123   }
3124 
3125   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3126     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3127         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3128   }
3129   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.GpuWorkPeriodFtraceEvent)
3130   return target;
3131 }
3132 
ByteSizeLong() const3133 size_t GpuWorkPeriodFtraceEvent::ByteSizeLong() const {
3134 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.GpuWorkPeriodFtraceEvent)
3135   size_t total_size = 0;
3136 
3137   ::uint32_t cached_has_bits = 0;
3138   // Prevent compiler warnings about cached_has_bits being unused
3139   (void) cached_has_bits;
3140 
3141   cached_has_bits = _impl_._has_bits_[0];
3142   if (cached_has_bits & 0x0000001fu) {
3143     // optional uint32 gpu_id = 1;
3144     if (cached_has_bits & 0x00000001u) {
3145       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gpu_id());
3146     }
3147 
3148     // optional uint32 uid = 2;
3149     if (cached_has_bits & 0x00000002u) {
3150       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_uid());
3151     }
3152 
3153     // optional uint64 start_time_ns = 3;
3154     if (cached_has_bits & 0x00000004u) {
3155       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_start_time_ns());
3156     }
3157 
3158     // optional uint64 end_time_ns = 4;
3159     if (cached_has_bits & 0x00000008u) {
3160       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_end_time_ns());
3161     }
3162 
3163     // optional uint64 total_active_duration_ns = 5;
3164     if (cached_has_bits & 0x00000010u) {
3165       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_total_active_duration_ns());
3166     }
3167 
3168   }
3169   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3170     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3171   }
3172   int cached_size = ::_pbi::ToCachedSize(total_size);
3173   SetCachedSize(cached_size);
3174   return total_size;
3175 }
3176 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3177 void GpuWorkPeriodFtraceEvent::CheckTypeAndMergeFrom(
3178     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3179   MergeFrom(*::_pbi::DownCast<const GpuWorkPeriodFtraceEvent*>(
3180       &from));
3181 }
3182 
MergeFrom(const GpuWorkPeriodFtraceEvent & from)3183 void GpuWorkPeriodFtraceEvent::MergeFrom(const GpuWorkPeriodFtraceEvent& from) {
3184   GpuWorkPeriodFtraceEvent* const _this = this;
3185   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.GpuWorkPeriodFtraceEvent)
3186   GOOGLE_DCHECK_NE(&from, _this);
3187   ::uint32_t cached_has_bits = 0;
3188   (void) cached_has_bits;
3189 
3190   cached_has_bits = from._impl_._has_bits_[0];
3191   if (cached_has_bits & 0x0000001fu) {
3192     if (cached_has_bits & 0x00000001u) {
3193       _this->_impl_.gpu_id_ = from._impl_.gpu_id_;
3194     }
3195     if (cached_has_bits & 0x00000002u) {
3196       _this->_impl_.uid_ = from._impl_.uid_;
3197     }
3198     if (cached_has_bits & 0x00000004u) {
3199       _this->_impl_.start_time_ns_ = from._impl_.start_time_ns_;
3200     }
3201     if (cached_has_bits & 0x00000008u) {
3202       _this->_impl_.end_time_ns_ = from._impl_.end_time_ns_;
3203     }
3204     if (cached_has_bits & 0x00000010u) {
3205       _this->_impl_.total_active_duration_ns_ = from._impl_.total_active_duration_ns_;
3206     }
3207     _this->_impl_._has_bits_[0] |= cached_has_bits;
3208   }
3209   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3210 }
3211 
CopyFrom(const GpuWorkPeriodFtraceEvent & from)3212 void GpuWorkPeriodFtraceEvent::CopyFrom(const GpuWorkPeriodFtraceEvent& from) {
3213 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.GpuWorkPeriodFtraceEvent)
3214   if (&from == this) return;
3215   Clear();
3216   MergeFrom(from);
3217 }
3218 
IsInitialized() const3219 bool GpuWorkPeriodFtraceEvent::IsInitialized() const {
3220   return true;
3221 }
3222 
InternalSwap(GpuWorkPeriodFtraceEvent * other)3223 void GpuWorkPeriodFtraceEvent::InternalSwap(GpuWorkPeriodFtraceEvent* other) {
3224   using std::swap;
3225   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3226   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3227   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3228       PROTOBUF_FIELD_OFFSET(GpuWorkPeriodFtraceEvent, _impl_.total_active_duration_ns_)
3229       + sizeof(GpuWorkPeriodFtraceEvent::_impl_.total_active_duration_ns_)  // NOLINT
3230       - PROTOBUF_FIELD_OFFSET(GpuWorkPeriodFtraceEvent, _impl_.gpu_id_)>(
3231           reinterpret_cast<char*>(&_impl_.gpu_id_),
3232           reinterpret_cast<char*>(&other->_impl_.gpu_id_));
3233 }
3234 
GetTypeName() const3235 std::string GpuWorkPeriodFtraceEvent::GetTypeName() const {
3236   return "perfetto.protos.GpuWorkPeriodFtraceEvent";
3237 }
3238 
3239 
3240 // ===================================================================
3241 
3242 class DevicePmCallbackStartFtraceEvent::_Internal {
3243  public:
3244   using HasBits = decltype(std::declval<DevicePmCallbackStartFtraceEvent>()._impl_._has_bits_);
set_has_device(HasBits * has_bits)3245   static void set_has_device(HasBits* has_bits) {
3246     (*has_bits)[0] |= 1u;
3247   }
set_has_driver(HasBits * has_bits)3248   static void set_has_driver(HasBits* has_bits) {
3249     (*has_bits)[0] |= 2u;
3250   }
set_has_parent(HasBits * has_bits)3251   static void set_has_parent(HasBits* has_bits) {
3252     (*has_bits)[0] |= 4u;
3253   }
set_has_pm_ops(HasBits * has_bits)3254   static void set_has_pm_ops(HasBits* has_bits) {
3255     (*has_bits)[0] |= 8u;
3256   }
set_has_event(HasBits * has_bits)3257   static void set_has_event(HasBits* has_bits) {
3258     (*has_bits)[0] |= 16u;
3259   }
3260 };
3261 
DevicePmCallbackStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3262 DevicePmCallbackStartFtraceEvent::DevicePmCallbackStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3263                          bool is_message_owned)
3264   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3265   SharedCtor(arena, is_message_owned);
3266   // @@protoc_insertion_point(arena_constructor:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3267 }
DevicePmCallbackStartFtraceEvent(const DevicePmCallbackStartFtraceEvent & from)3268 DevicePmCallbackStartFtraceEvent::DevicePmCallbackStartFtraceEvent(const DevicePmCallbackStartFtraceEvent& from)
3269   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3270   DevicePmCallbackStartFtraceEvent* const _this = this; (void)_this;
3271   new (&_impl_) Impl_{
3272       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3273     , /*decltype(_impl_._cached_size_)*/{}
3274     , decltype(_impl_.device_){}
3275     , decltype(_impl_.driver_){}
3276     , decltype(_impl_.parent_){}
3277     , decltype(_impl_.pm_ops_){}
3278     , decltype(_impl_.event_){}};
3279 
3280   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3281   _impl_.device_.InitDefault();
3282   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3283     _impl_.device_.Set("", GetArenaForAllocation());
3284   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3285   if (from._internal_has_device()) {
3286     _this->_impl_.device_.Set(from._internal_device(),
3287       _this->GetArenaForAllocation());
3288   }
3289   _impl_.driver_.InitDefault();
3290   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3291     _impl_.driver_.Set("", GetArenaForAllocation());
3292   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3293   if (from._internal_has_driver()) {
3294     _this->_impl_.driver_.Set(from._internal_driver(),
3295       _this->GetArenaForAllocation());
3296   }
3297   _impl_.parent_.InitDefault();
3298   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3299     _impl_.parent_.Set("", GetArenaForAllocation());
3300   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3301   if (from._internal_has_parent()) {
3302     _this->_impl_.parent_.Set(from._internal_parent(),
3303       _this->GetArenaForAllocation());
3304   }
3305   _impl_.pm_ops_.InitDefault();
3306   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3307     _impl_.pm_ops_.Set("", GetArenaForAllocation());
3308   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3309   if (from._internal_has_pm_ops()) {
3310     _this->_impl_.pm_ops_.Set(from._internal_pm_ops(),
3311       _this->GetArenaForAllocation());
3312   }
3313   _this->_impl_.event_ = from._impl_.event_;
3314   // @@protoc_insertion_point(copy_constructor:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3315 }
3316 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3317 inline void DevicePmCallbackStartFtraceEvent::SharedCtor(
3318     ::_pb::Arena* arena, bool is_message_owned) {
3319   (void)arena;
3320   (void)is_message_owned;
3321   new (&_impl_) Impl_{
3322       decltype(_impl_._has_bits_){}
3323     , /*decltype(_impl_._cached_size_)*/{}
3324     , decltype(_impl_.device_){}
3325     , decltype(_impl_.driver_){}
3326     , decltype(_impl_.parent_){}
3327     , decltype(_impl_.pm_ops_){}
3328     , decltype(_impl_.event_){0}
3329   };
3330   _impl_.device_.InitDefault();
3331   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3332     _impl_.device_.Set("", GetArenaForAllocation());
3333   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3334   _impl_.driver_.InitDefault();
3335   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3336     _impl_.driver_.Set("", GetArenaForAllocation());
3337   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3338   _impl_.parent_.InitDefault();
3339   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3340     _impl_.parent_.Set("", GetArenaForAllocation());
3341   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3342   _impl_.pm_ops_.InitDefault();
3343   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3344     _impl_.pm_ops_.Set("", GetArenaForAllocation());
3345   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3346 }
3347 
~DevicePmCallbackStartFtraceEvent()3348 DevicePmCallbackStartFtraceEvent::~DevicePmCallbackStartFtraceEvent() {
3349   // @@protoc_insertion_point(destructor:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3350   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3351   (void)arena;
3352     return;
3353   }
3354   SharedDtor();
3355 }
3356 
SharedDtor()3357 inline void DevicePmCallbackStartFtraceEvent::SharedDtor() {
3358   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3359   _impl_.device_.Destroy();
3360   _impl_.driver_.Destroy();
3361   _impl_.parent_.Destroy();
3362   _impl_.pm_ops_.Destroy();
3363 }
3364 
SetCachedSize(int size) const3365 void DevicePmCallbackStartFtraceEvent::SetCachedSize(int size) const {
3366   _impl_._cached_size_.Set(size);
3367 }
3368 
Clear()3369 void DevicePmCallbackStartFtraceEvent::Clear() {
3370 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3371   ::uint32_t cached_has_bits = 0;
3372   // Prevent compiler warnings about cached_has_bits being unused
3373   (void) cached_has_bits;
3374 
3375   cached_has_bits = _impl_._has_bits_[0];
3376   if (cached_has_bits & 0x0000000fu) {
3377     if (cached_has_bits & 0x00000001u) {
3378       _impl_.device_.ClearNonDefaultToEmpty();
3379     }
3380     if (cached_has_bits & 0x00000002u) {
3381       _impl_.driver_.ClearNonDefaultToEmpty();
3382     }
3383     if (cached_has_bits & 0x00000004u) {
3384       _impl_.parent_.ClearNonDefaultToEmpty();
3385     }
3386     if (cached_has_bits & 0x00000008u) {
3387       _impl_.pm_ops_.ClearNonDefaultToEmpty();
3388     }
3389   }
3390   _impl_.event_ = 0;
3391   _impl_._has_bits_.Clear();
3392   _internal_metadata_.Clear<std::string>();
3393 }
3394 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3395 const char* DevicePmCallbackStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3396 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3397   _Internal::HasBits has_bits{};
3398   while (!ctx->Done(&ptr)) {
3399     ::uint32_t tag;
3400     ptr = ::_pbi::ReadTag(ptr, &tag);
3401     switch (tag >> 3) {
3402       // optional string device = 1;
3403       case 1:
3404         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3405           auto str = _internal_mutable_device();
3406           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3407           CHK_(ptr);
3408         } else {
3409           goto handle_unusual;
3410         }
3411         continue;
3412       // optional string driver = 2;
3413       case 2:
3414         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3415           auto str = _internal_mutable_driver();
3416           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3417           CHK_(ptr);
3418         } else {
3419           goto handle_unusual;
3420         }
3421         continue;
3422       // optional string parent = 3;
3423       case 3:
3424         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
3425           auto str = _internal_mutable_parent();
3426           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3427           CHK_(ptr);
3428         } else {
3429           goto handle_unusual;
3430         }
3431         continue;
3432       // optional string pm_ops = 4;
3433       case 4:
3434         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
3435           auto str = _internal_mutable_pm_ops();
3436           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3437           CHK_(ptr);
3438         } else {
3439           goto handle_unusual;
3440         }
3441         continue;
3442       // optional int32 event = 5;
3443       case 5:
3444         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3445           _Internal::set_has_event(&has_bits);
3446           _impl_.event_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3447           CHK_(ptr);
3448         } else {
3449           goto handle_unusual;
3450         }
3451         continue;
3452       default:
3453         goto handle_unusual;
3454     }  // switch
3455   handle_unusual:
3456     if ((tag == 0) || ((tag & 7) == 4)) {
3457       CHK_(ptr);
3458       ctx->SetLastTag(tag);
3459       goto message_done;
3460     }
3461     ptr = UnknownFieldParse(
3462         tag,
3463         _internal_metadata_.mutable_unknown_fields<std::string>(),
3464         ptr, ctx);
3465     CHK_(ptr != nullptr);
3466   }  // while
3467 message_done:
3468   _impl_._has_bits_.Or(has_bits);
3469   return ptr;
3470 failure:
3471   ptr = nullptr;
3472   goto message_done;
3473 #undef CHK_
3474 }
3475 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3476 ::uint8_t* DevicePmCallbackStartFtraceEvent::_InternalSerialize(
3477     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3478   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3479   ::uint32_t cached_has_bits = 0;
3480   (void) cached_has_bits;
3481 
3482   cached_has_bits = _impl_._has_bits_[0];
3483   // optional string device = 1;
3484   if (cached_has_bits & 0x00000001u) {
3485     target = stream->WriteStringMaybeAliased(
3486         1, this->_internal_device(), target);
3487   }
3488 
3489   // optional string driver = 2;
3490   if (cached_has_bits & 0x00000002u) {
3491     target = stream->WriteStringMaybeAliased(
3492         2, this->_internal_driver(), target);
3493   }
3494 
3495   // optional string parent = 3;
3496   if (cached_has_bits & 0x00000004u) {
3497     target = stream->WriteStringMaybeAliased(
3498         3, this->_internal_parent(), target);
3499   }
3500 
3501   // optional string pm_ops = 4;
3502   if (cached_has_bits & 0x00000008u) {
3503     target = stream->WriteStringMaybeAliased(
3504         4, this->_internal_pm_ops(), target);
3505   }
3506 
3507   // optional int32 event = 5;
3508   if (cached_has_bits & 0x00000010u) {
3509     target = stream->EnsureSpace(target);
3510     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_event(), target);
3511   }
3512 
3513   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3514     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3515         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3516   }
3517   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3518   return target;
3519 }
3520 
ByteSizeLong() const3521 size_t DevicePmCallbackStartFtraceEvent::ByteSizeLong() const {
3522 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3523   size_t total_size = 0;
3524 
3525   ::uint32_t cached_has_bits = 0;
3526   // Prevent compiler warnings about cached_has_bits being unused
3527   (void) cached_has_bits;
3528 
3529   cached_has_bits = _impl_._has_bits_[0];
3530   if (cached_has_bits & 0x0000001fu) {
3531     // optional string device = 1;
3532     if (cached_has_bits & 0x00000001u) {
3533       total_size += 1 +
3534         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3535           this->_internal_device());
3536     }
3537 
3538     // optional string driver = 2;
3539     if (cached_has_bits & 0x00000002u) {
3540       total_size += 1 +
3541         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3542           this->_internal_driver());
3543     }
3544 
3545     // optional string parent = 3;
3546     if (cached_has_bits & 0x00000004u) {
3547       total_size += 1 +
3548         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3549           this->_internal_parent());
3550     }
3551 
3552     // optional string pm_ops = 4;
3553     if (cached_has_bits & 0x00000008u) {
3554       total_size += 1 +
3555         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3556           this->_internal_pm_ops());
3557     }
3558 
3559     // optional int32 event = 5;
3560     if (cached_has_bits & 0x00000010u) {
3561       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_event());
3562     }
3563 
3564   }
3565   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3566     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3567   }
3568   int cached_size = ::_pbi::ToCachedSize(total_size);
3569   SetCachedSize(cached_size);
3570   return total_size;
3571 }
3572 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3573 void DevicePmCallbackStartFtraceEvent::CheckTypeAndMergeFrom(
3574     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3575   MergeFrom(*::_pbi::DownCast<const DevicePmCallbackStartFtraceEvent*>(
3576       &from));
3577 }
3578 
MergeFrom(const DevicePmCallbackStartFtraceEvent & from)3579 void DevicePmCallbackStartFtraceEvent::MergeFrom(const DevicePmCallbackStartFtraceEvent& from) {
3580   DevicePmCallbackStartFtraceEvent* const _this = this;
3581   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3582   GOOGLE_DCHECK_NE(&from, _this);
3583   ::uint32_t cached_has_bits = 0;
3584   (void) cached_has_bits;
3585 
3586   cached_has_bits = from._impl_._has_bits_[0];
3587   if (cached_has_bits & 0x0000001fu) {
3588     if (cached_has_bits & 0x00000001u) {
3589       _this->_internal_set_device(from._internal_device());
3590     }
3591     if (cached_has_bits & 0x00000002u) {
3592       _this->_internal_set_driver(from._internal_driver());
3593     }
3594     if (cached_has_bits & 0x00000004u) {
3595       _this->_internal_set_parent(from._internal_parent());
3596     }
3597     if (cached_has_bits & 0x00000008u) {
3598       _this->_internal_set_pm_ops(from._internal_pm_ops());
3599     }
3600     if (cached_has_bits & 0x00000010u) {
3601       _this->_impl_.event_ = from._impl_.event_;
3602     }
3603     _this->_impl_._has_bits_[0] |= cached_has_bits;
3604   }
3605   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3606 }
3607 
CopyFrom(const DevicePmCallbackStartFtraceEvent & from)3608 void DevicePmCallbackStartFtraceEvent::CopyFrom(const DevicePmCallbackStartFtraceEvent& from) {
3609 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DevicePmCallbackStartFtraceEvent)
3610   if (&from == this) return;
3611   Clear();
3612   MergeFrom(from);
3613 }
3614 
IsInitialized() const3615 bool DevicePmCallbackStartFtraceEvent::IsInitialized() const {
3616   return true;
3617 }
3618 
InternalSwap(DevicePmCallbackStartFtraceEvent * other)3619 void DevicePmCallbackStartFtraceEvent::InternalSwap(DevicePmCallbackStartFtraceEvent* other) {
3620   using std::swap;
3621   auto* lhs_arena = GetArenaForAllocation();
3622   auto* rhs_arena = other->GetArenaForAllocation();
3623   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3624   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3625   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3626       &_impl_.device_, lhs_arena,
3627       &other->_impl_.device_, rhs_arena
3628   );
3629   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3630       &_impl_.driver_, lhs_arena,
3631       &other->_impl_.driver_, rhs_arena
3632   );
3633   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3634       &_impl_.parent_, lhs_arena,
3635       &other->_impl_.parent_, rhs_arena
3636   );
3637   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3638       &_impl_.pm_ops_, lhs_arena,
3639       &other->_impl_.pm_ops_, rhs_arena
3640   );
3641   swap(_impl_.event_, other->_impl_.event_);
3642 }
3643 
GetTypeName() const3644 std::string DevicePmCallbackStartFtraceEvent::GetTypeName() const {
3645   return "perfetto.protos.DevicePmCallbackStartFtraceEvent";
3646 }
3647 
3648 
3649 // ===================================================================
3650 
3651 class DevicePmCallbackEndFtraceEvent::_Internal {
3652  public:
3653   using HasBits = decltype(std::declval<DevicePmCallbackEndFtraceEvent>()._impl_._has_bits_);
set_has_device(HasBits * has_bits)3654   static void set_has_device(HasBits* has_bits) {
3655     (*has_bits)[0] |= 1u;
3656   }
set_has_driver(HasBits * has_bits)3657   static void set_has_driver(HasBits* has_bits) {
3658     (*has_bits)[0] |= 2u;
3659   }
set_has_error(HasBits * has_bits)3660   static void set_has_error(HasBits* has_bits) {
3661     (*has_bits)[0] |= 4u;
3662   }
3663 };
3664 
DevicePmCallbackEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3665 DevicePmCallbackEndFtraceEvent::DevicePmCallbackEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3666                          bool is_message_owned)
3667   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3668   SharedCtor(arena, is_message_owned);
3669   // @@protoc_insertion_point(arena_constructor:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3670 }
DevicePmCallbackEndFtraceEvent(const DevicePmCallbackEndFtraceEvent & from)3671 DevicePmCallbackEndFtraceEvent::DevicePmCallbackEndFtraceEvent(const DevicePmCallbackEndFtraceEvent& from)
3672   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3673   DevicePmCallbackEndFtraceEvent* const _this = this; (void)_this;
3674   new (&_impl_) Impl_{
3675       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3676     , /*decltype(_impl_._cached_size_)*/{}
3677     , decltype(_impl_.device_){}
3678     , decltype(_impl_.driver_){}
3679     , decltype(_impl_.error_){}};
3680 
3681   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3682   _impl_.device_.InitDefault();
3683   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3684     _impl_.device_.Set("", GetArenaForAllocation());
3685   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3686   if (from._internal_has_device()) {
3687     _this->_impl_.device_.Set(from._internal_device(),
3688       _this->GetArenaForAllocation());
3689   }
3690   _impl_.driver_.InitDefault();
3691   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3692     _impl_.driver_.Set("", GetArenaForAllocation());
3693   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3694   if (from._internal_has_driver()) {
3695     _this->_impl_.driver_.Set(from._internal_driver(),
3696       _this->GetArenaForAllocation());
3697   }
3698   _this->_impl_.error_ = from._impl_.error_;
3699   // @@protoc_insertion_point(copy_constructor:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3700 }
3701 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3702 inline void DevicePmCallbackEndFtraceEvent::SharedCtor(
3703     ::_pb::Arena* arena, bool is_message_owned) {
3704   (void)arena;
3705   (void)is_message_owned;
3706   new (&_impl_) Impl_{
3707       decltype(_impl_._has_bits_){}
3708     , /*decltype(_impl_._cached_size_)*/{}
3709     , decltype(_impl_.device_){}
3710     , decltype(_impl_.driver_){}
3711     , decltype(_impl_.error_){0}
3712   };
3713   _impl_.device_.InitDefault();
3714   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3715     _impl_.device_.Set("", GetArenaForAllocation());
3716   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3717   _impl_.driver_.InitDefault();
3718   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3719     _impl_.driver_.Set("", GetArenaForAllocation());
3720   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3721 }
3722 
~DevicePmCallbackEndFtraceEvent()3723 DevicePmCallbackEndFtraceEvent::~DevicePmCallbackEndFtraceEvent() {
3724   // @@protoc_insertion_point(destructor:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3725   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3726   (void)arena;
3727     return;
3728   }
3729   SharedDtor();
3730 }
3731 
SharedDtor()3732 inline void DevicePmCallbackEndFtraceEvent::SharedDtor() {
3733   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3734   _impl_.device_.Destroy();
3735   _impl_.driver_.Destroy();
3736 }
3737 
SetCachedSize(int size) const3738 void DevicePmCallbackEndFtraceEvent::SetCachedSize(int size) const {
3739   _impl_._cached_size_.Set(size);
3740 }
3741 
Clear()3742 void DevicePmCallbackEndFtraceEvent::Clear() {
3743 // @@protoc_insertion_point(message_clear_start:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3744   ::uint32_t cached_has_bits = 0;
3745   // Prevent compiler warnings about cached_has_bits being unused
3746   (void) cached_has_bits;
3747 
3748   cached_has_bits = _impl_._has_bits_[0];
3749   if (cached_has_bits & 0x00000003u) {
3750     if (cached_has_bits & 0x00000001u) {
3751       _impl_.device_.ClearNonDefaultToEmpty();
3752     }
3753     if (cached_has_bits & 0x00000002u) {
3754       _impl_.driver_.ClearNonDefaultToEmpty();
3755     }
3756   }
3757   _impl_.error_ = 0;
3758   _impl_._has_bits_.Clear();
3759   _internal_metadata_.Clear<std::string>();
3760 }
3761 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3762 const char* DevicePmCallbackEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3763 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3764   _Internal::HasBits has_bits{};
3765   while (!ctx->Done(&ptr)) {
3766     ::uint32_t tag;
3767     ptr = ::_pbi::ReadTag(ptr, &tag);
3768     switch (tag >> 3) {
3769       // optional string device = 1;
3770       case 1:
3771         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3772           auto str = _internal_mutable_device();
3773           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3774           CHK_(ptr);
3775         } else {
3776           goto handle_unusual;
3777         }
3778         continue;
3779       // optional string driver = 2;
3780       case 2:
3781         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
3782           auto str = _internal_mutable_driver();
3783           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3784           CHK_(ptr);
3785         } else {
3786           goto handle_unusual;
3787         }
3788         continue;
3789       // optional int32 error = 3;
3790       case 3:
3791         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3792           _Internal::set_has_error(&has_bits);
3793           _impl_.error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3794           CHK_(ptr);
3795         } else {
3796           goto handle_unusual;
3797         }
3798         continue;
3799       default:
3800         goto handle_unusual;
3801     }  // switch
3802   handle_unusual:
3803     if ((tag == 0) || ((tag & 7) == 4)) {
3804       CHK_(ptr);
3805       ctx->SetLastTag(tag);
3806       goto message_done;
3807     }
3808     ptr = UnknownFieldParse(
3809         tag,
3810         _internal_metadata_.mutable_unknown_fields<std::string>(),
3811         ptr, ctx);
3812     CHK_(ptr != nullptr);
3813   }  // while
3814 message_done:
3815   _impl_._has_bits_.Or(has_bits);
3816   return ptr;
3817 failure:
3818   ptr = nullptr;
3819   goto message_done;
3820 #undef CHK_
3821 }
3822 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3823 ::uint8_t* DevicePmCallbackEndFtraceEvent::_InternalSerialize(
3824     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3825   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3826   ::uint32_t cached_has_bits = 0;
3827   (void) cached_has_bits;
3828 
3829   cached_has_bits = _impl_._has_bits_[0];
3830   // optional string device = 1;
3831   if (cached_has_bits & 0x00000001u) {
3832     target = stream->WriteStringMaybeAliased(
3833         1, this->_internal_device(), target);
3834   }
3835 
3836   // optional string driver = 2;
3837   if (cached_has_bits & 0x00000002u) {
3838     target = stream->WriteStringMaybeAliased(
3839         2, this->_internal_driver(), target);
3840   }
3841 
3842   // optional int32 error = 3;
3843   if (cached_has_bits & 0x00000004u) {
3844     target = stream->EnsureSpace(target);
3845     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_error(), target);
3846   }
3847 
3848   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3849     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3850         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3851   }
3852   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3853   return target;
3854 }
3855 
ByteSizeLong() const3856 size_t DevicePmCallbackEndFtraceEvent::ByteSizeLong() const {
3857 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3858   size_t total_size = 0;
3859 
3860   ::uint32_t cached_has_bits = 0;
3861   // Prevent compiler warnings about cached_has_bits being unused
3862   (void) cached_has_bits;
3863 
3864   cached_has_bits = _impl_._has_bits_[0];
3865   if (cached_has_bits & 0x00000007u) {
3866     // optional string device = 1;
3867     if (cached_has_bits & 0x00000001u) {
3868       total_size += 1 +
3869         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3870           this->_internal_device());
3871     }
3872 
3873     // optional string driver = 2;
3874     if (cached_has_bits & 0x00000002u) {
3875       total_size += 1 +
3876         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3877           this->_internal_driver());
3878     }
3879 
3880     // optional int32 error = 3;
3881     if (cached_has_bits & 0x00000004u) {
3882       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_error());
3883     }
3884 
3885   }
3886   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3887     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3888   }
3889   int cached_size = ::_pbi::ToCachedSize(total_size);
3890   SetCachedSize(cached_size);
3891   return total_size;
3892 }
3893 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3894 void DevicePmCallbackEndFtraceEvent::CheckTypeAndMergeFrom(
3895     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3896   MergeFrom(*::_pbi::DownCast<const DevicePmCallbackEndFtraceEvent*>(
3897       &from));
3898 }
3899 
MergeFrom(const DevicePmCallbackEndFtraceEvent & from)3900 void DevicePmCallbackEndFtraceEvent::MergeFrom(const DevicePmCallbackEndFtraceEvent& from) {
3901   DevicePmCallbackEndFtraceEvent* const _this = this;
3902   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3903   GOOGLE_DCHECK_NE(&from, _this);
3904   ::uint32_t cached_has_bits = 0;
3905   (void) cached_has_bits;
3906 
3907   cached_has_bits = from._impl_._has_bits_[0];
3908   if (cached_has_bits & 0x00000007u) {
3909     if (cached_has_bits & 0x00000001u) {
3910       _this->_internal_set_device(from._internal_device());
3911     }
3912     if (cached_has_bits & 0x00000002u) {
3913       _this->_internal_set_driver(from._internal_driver());
3914     }
3915     if (cached_has_bits & 0x00000004u) {
3916       _this->_impl_.error_ = from._impl_.error_;
3917     }
3918     _this->_impl_._has_bits_[0] |= cached_has_bits;
3919   }
3920   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3921 }
3922 
CopyFrom(const DevicePmCallbackEndFtraceEvent & from)3923 void DevicePmCallbackEndFtraceEvent::CopyFrom(const DevicePmCallbackEndFtraceEvent& from) {
3924 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.DevicePmCallbackEndFtraceEvent)
3925   if (&from == this) return;
3926   Clear();
3927   MergeFrom(from);
3928 }
3929 
IsInitialized() const3930 bool DevicePmCallbackEndFtraceEvent::IsInitialized() const {
3931   return true;
3932 }
3933 
InternalSwap(DevicePmCallbackEndFtraceEvent * other)3934 void DevicePmCallbackEndFtraceEvent::InternalSwap(DevicePmCallbackEndFtraceEvent* other) {
3935   using std::swap;
3936   auto* lhs_arena = GetArenaForAllocation();
3937   auto* rhs_arena = other->GetArenaForAllocation();
3938   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3939   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3940   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3941       &_impl_.device_, lhs_arena,
3942       &other->_impl_.device_, rhs_arena
3943   );
3944   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3945       &_impl_.driver_, lhs_arena,
3946       &other->_impl_.driver_, rhs_arena
3947   );
3948   swap(_impl_.error_, other->_impl_.error_);
3949 }
3950 
GetTypeName() const3951 std::string DevicePmCallbackEndFtraceEvent::GetTypeName() const {
3952   return "perfetto.protos.DevicePmCallbackEndFtraceEvent";
3953 }
3954 
3955 
3956 // @@protoc_insertion_point(namespace_scope)
3957 }  // namespace protos
3958 }  // namespace perfetto
3959 PROTOBUF_NAMESPACE_OPEN
3960 template<> PROTOBUF_NOINLINE ::perfetto::protos::CpuFrequencyFtraceEvent*
CreateMaybeMessage(Arena * arena)3961 Arena::CreateMaybeMessage< ::perfetto::protos::CpuFrequencyFtraceEvent >(Arena* arena) {
3962   return Arena::CreateMessageInternal< ::perfetto::protos::CpuFrequencyFtraceEvent >(arena);
3963 }
3964 template<> PROTOBUF_NOINLINE ::perfetto::protos::CpuFrequencyLimitsFtraceEvent*
CreateMaybeMessage(Arena * arena)3965 Arena::CreateMaybeMessage< ::perfetto::protos::CpuFrequencyLimitsFtraceEvent >(Arena* arena) {
3966   return Arena::CreateMessageInternal< ::perfetto::protos::CpuFrequencyLimitsFtraceEvent >(arena);
3967 }
3968 template<> PROTOBUF_NOINLINE ::perfetto::protos::CpuIdleFtraceEvent*
CreateMaybeMessage(Arena * arena)3969 Arena::CreateMaybeMessage< ::perfetto::protos::CpuIdleFtraceEvent >(Arena* arena) {
3970   return Arena::CreateMessageInternal< ::perfetto::protos::CpuIdleFtraceEvent >(arena);
3971 }
3972 template<> PROTOBUF_NOINLINE ::perfetto::protos::ClockEnableFtraceEvent*
CreateMaybeMessage(Arena * arena)3973 Arena::CreateMaybeMessage< ::perfetto::protos::ClockEnableFtraceEvent >(Arena* arena) {
3974   return Arena::CreateMessageInternal< ::perfetto::protos::ClockEnableFtraceEvent >(arena);
3975 }
3976 template<> PROTOBUF_NOINLINE ::perfetto::protos::ClockDisableFtraceEvent*
CreateMaybeMessage(Arena * arena)3977 Arena::CreateMaybeMessage< ::perfetto::protos::ClockDisableFtraceEvent >(Arena* arena) {
3978   return Arena::CreateMessageInternal< ::perfetto::protos::ClockDisableFtraceEvent >(arena);
3979 }
3980 template<> PROTOBUF_NOINLINE ::perfetto::protos::ClockSetRateFtraceEvent*
CreateMaybeMessage(Arena * arena)3981 Arena::CreateMaybeMessage< ::perfetto::protos::ClockSetRateFtraceEvent >(Arena* arena) {
3982   return Arena::CreateMessageInternal< ::perfetto::protos::ClockSetRateFtraceEvent >(arena);
3983 }
3984 template<> PROTOBUF_NOINLINE ::perfetto::protos::SuspendResumeFtraceEvent*
CreateMaybeMessage(Arena * arena)3985 Arena::CreateMaybeMessage< ::perfetto::protos::SuspendResumeFtraceEvent >(Arena* arena) {
3986   return Arena::CreateMessageInternal< ::perfetto::protos::SuspendResumeFtraceEvent >(arena);
3987 }
3988 template<> PROTOBUF_NOINLINE ::perfetto::protos::GpuFrequencyFtraceEvent*
CreateMaybeMessage(Arena * arena)3989 Arena::CreateMaybeMessage< ::perfetto::protos::GpuFrequencyFtraceEvent >(Arena* arena) {
3990   return Arena::CreateMessageInternal< ::perfetto::protos::GpuFrequencyFtraceEvent >(arena);
3991 }
3992 template<> PROTOBUF_NOINLINE ::perfetto::protos::WakeupSourceActivateFtraceEvent*
CreateMaybeMessage(Arena * arena)3993 Arena::CreateMaybeMessage< ::perfetto::protos::WakeupSourceActivateFtraceEvent >(Arena* arena) {
3994   return Arena::CreateMessageInternal< ::perfetto::protos::WakeupSourceActivateFtraceEvent >(arena);
3995 }
3996 template<> PROTOBUF_NOINLINE ::perfetto::protos::WakeupSourceDeactivateFtraceEvent*
CreateMaybeMessage(Arena * arena)3997 Arena::CreateMaybeMessage< ::perfetto::protos::WakeupSourceDeactivateFtraceEvent >(Arena* arena) {
3998   return Arena::CreateMessageInternal< ::perfetto::protos::WakeupSourceDeactivateFtraceEvent >(arena);
3999 }
4000 template<> PROTOBUF_NOINLINE ::perfetto::protos::GpuWorkPeriodFtraceEvent*
CreateMaybeMessage(Arena * arena)4001 Arena::CreateMaybeMessage< ::perfetto::protos::GpuWorkPeriodFtraceEvent >(Arena* arena) {
4002   return Arena::CreateMessageInternal< ::perfetto::protos::GpuWorkPeriodFtraceEvent >(arena);
4003 }
4004 template<> PROTOBUF_NOINLINE ::perfetto::protos::DevicePmCallbackStartFtraceEvent*
CreateMaybeMessage(Arena * arena)4005 Arena::CreateMaybeMessage< ::perfetto::protos::DevicePmCallbackStartFtraceEvent >(Arena* arena) {
4006   return Arena::CreateMessageInternal< ::perfetto::protos::DevicePmCallbackStartFtraceEvent >(arena);
4007 }
4008 template<> PROTOBUF_NOINLINE ::perfetto::protos::DevicePmCallbackEndFtraceEvent*
CreateMaybeMessage(Arena * arena)4009 Arena::CreateMaybeMessage< ::perfetto::protos::DevicePmCallbackEndFtraceEvent >(Arena* arena) {
4010   return Arena::CreateMessageInternal< ::perfetto::protos::DevicePmCallbackEndFtraceEvent >(arena);
4011 }
4012 PROTOBUF_NAMESPACE_CLOSE
4013 
4014 // @@protoc_insertion_point(global_scope)
4015 #include <google/protobuf/port_undef.inc>
4016