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