1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/sched.proto
3 
4 #include "protos/perfetto/trace/ftrace/sched.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 {
SchedSwitchFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SchedSwitchFtraceEvent::SchedSwitchFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.prev_comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.next_comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.prev_pid_)*/0
30   , /*decltype(_impl_.prev_prio_)*/0
31   , /*decltype(_impl_.prev_state_)*/::int64_t{0}
32   , /*decltype(_impl_.next_pid_)*/0
33   , /*decltype(_impl_.next_prio_)*/0} {}
34 struct SchedSwitchFtraceEventDefaultTypeInternal {
SchedSwitchFtraceEventDefaultTypeInternalperfetto::protos::SchedSwitchFtraceEventDefaultTypeInternal35   PROTOBUF_CONSTEXPR SchedSwitchFtraceEventDefaultTypeInternal()
36       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedSwitchFtraceEventDefaultTypeInternalperfetto::protos::SchedSwitchFtraceEventDefaultTypeInternal37   ~SchedSwitchFtraceEventDefaultTypeInternal() {}
38   union {  // NOLINT(misc-non-private-member-variables-in-classes)
39     SchedSwitchFtraceEvent _instance;
40   };
41 };
42 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedSwitchFtraceEventDefaultTypeInternal _SchedSwitchFtraceEvent_default_instance_;
SchedWakeupFtraceEvent(::_pbi::ConstantInitialized)43 PROTOBUF_CONSTEXPR SchedWakeupFtraceEvent::SchedWakeupFtraceEvent(
44     ::_pbi::ConstantInitialized): _impl_{
45     /*decltype(_impl_._has_bits_)*/{}
46   , /*decltype(_impl_._cached_size_)*/{}
47   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
48   , /*decltype(_impl_.pid_)*/0
49   , /*decltype(_impl_.prio_)*/0
50   , /*decltype(_impl_.success_)*/0
51   , /*decltype(_impl_.target_cpu_)*/0} {}
52 struct SchedWakeupFtraceEventDefaultTypeInternal {
SchedWakeupFtraceEventDefaultTypeInternalperfetto::protos::SchedWakeupFtraceEventDefaultTypeInternal53   PROTOBUF_CONSTEXPR SchedWakeupFtraceEventDefaultTypeInternal()
54       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedWakeupFtraceEventDefaultTypeInternalperfetto::protos::SchedWakeupFtraceEventDefaultTypeInternal55   ~SchedWakeupFtraceEventDefaultTypeInternal() {}
56   union {  // NOLINT(misc-non-private-member-variables-in-classes)
57     SchedWakeupFtraceEvent _instance;
58   };
59 };
60 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedWakeupFtraceEventDefaultTypeInternal _SchedWakeupFtraceEvent_default_instance_;
SchedBlockedReasonFtraceEvent(::_pbi::ConstantInitialized)61 PROTOBUF_CONSTEXPR SchedBlockedReasonFtraceEvent::SchedBlockedReasonFtraceEvent(
62     ::_pbi::ConstantInitialized): _impl_{
63     /*decltype(_impl_._has_bits_)*/{}
64   , /*decltype(_impl_._cached_size_)*/{}
65   , /*decltype(_impl_.caller_)*/::uint64_t{0u}
66   , /*decltype(_impl_.pid_)*/0
67   , /*decltype(_impl_.io_wait_)*/0u} {}
68 struct SchedBlockedReasonFtraceEventDefaultTypeInternal {
SchedBlockedReasonFtraceEventDefaultTypeInternalperfetto::protos::SchedBlockedReasonFtraceEventDefaultTypeInternal69   PROTOBUF_CONSTEXPR SchedBlockedReasonFtraceEventDefaultTypeInternal()
70       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedBlockedReasonFtraceEventDefaultTypeInternalperfetto::protos::SchedBlockedReasonFtraceEventDefaultTypeInternal71   ~SchedBlockedReasonFtraceEventDefaultTypeInternal() {}
72   union {  // NOLINT(misc-non-private-member-variables-in-classes)
73     SchedBlockedReasonFtraceEvent _instance;
74   };
75 };
76 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedBlockedReasonFtraceEventDefaultTypeInternal _SchedBlockedReasonFtraceEvent_default_instance_;
SchedCpuHotplugFtraceEvent(::_pbi::ConstantInitialized)77 PROTOBUF_CONSTEXPR SchedCpuHotplugFtraceEvent::SchedCpuHotplugFtraceEvent(
78     ::_pbi::ConstantInitialized): _impl_{
79     /*decltype(_impl_._has_bits_)*/{}
80   , /*decltype(_impl_._cached_size_)*/{}
81   , /*decltype(_impl_.affected_cpu_)*/0
82   , /*decltype(_impl_.error_)*/0
83   , /*decltype(_impl_.status_)*/0} {}
84 struct SchedCpuHotplugFtraceEventDefaultTypeInternal {
SchedCpuHotplugFtraceEventDefaultTypeInternalperfetto::protos::SchedCpuHotplugFtraceEventDefaultTypeInternal85   PROTOBUF_CONSTEXPR SchedCpuHotplugFtraceEventDefaultTypeInternal()
86       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedCpuHotplugFtraceEventDefaultTypeInternalperfetto::protos::SchedCpuHotplugFtraceEventDefaultTypeInternal87   ~SchedCpuHotplugFtraceEventDefaultTypeInternal() {}
88   union {  // NOLINT(misc-non-private-member-variables-in-classes)
89     SchedCpuHotplugFtraceEvent _instance;
90   };
91 };
92 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedCpuHotplugFtraceEventDefaultTypeInternal _SchedCpuHotplugFtraceEvent_default_instance_;
SchedWakingFtraceEvent(::_pbi::ConstantInitialized)93 PROTOBUF_CONSTEXPR SchedWakingFtraceEvent::SchedWakingFtraceEvent(
94     ::_pbi::ConstantInitialized): _impl_{
95     /*decltype(_impl_._has_bits_)*/{}
96   , /*decltype(_impl_._cached_size_)*/{}
97   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
98   , /*decltype(_impl_.pid_)*/0
99   , /*decltype(_impl_.prio_)*/0
100   , /*decltype(_impl_.success_)*/0
101   , /*decltype(_impl_.target_cpu_)*/0} {}
102 struct SchedWakingFtraceEventDefaultTypeInternal {
SchedWakingFtraceEventDefaultTypeInternalperfetto::protos::SchedWakingFtraceEventDefaultTypeInternal103   PROTOBUF_CONSTEXPR SchedWakingFtraceEventDefaultTypeInternal()
104       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedWakingFtraceEventDefaultTypeInternalperfetto::protos::SchedWakingFtraceEventDefaultTypeInternal105   ~SchedWakingFtraceEventDefaultTypeInternal() {}
106   union {  // NOLINT(misc-non-private-member-variables-in-classes)
107     SchedWakingFtraceEvent _instance;
108   };
109 };
110 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedWakingFtraceEventDefaultTypeInternal _SchedWakingFtraceEvent_default_instance_;
SchedWakeupNewFtraceEvent(::_pbi::ConstantInitialized)111 PROTOBUF_CONSTEXPR SchedWakeupNewFtraceEvent::SchedWakeupNewFtraceEvent(
112     ::_pbi::ConstantInitialized): _impl_{
113     /*decltype(_impl_._has_bits_)*/{}
114   , /*decltype(_impl_._cached_size_)*/{}
115   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
116   , /*decltype(_impl_.pid_)*/0
117   , /*decltype(_impl_.prio_)*/0
118   , /*decltype(_impl_.success_)*/0
119   , /*decltype(_impl_.target_cpu_)*/0} {}
120 struct SchedWakeupNewFtraceEventDefaultTypeInternal {
SchedWakeupNewFtraceEventDefaultTypeInternalperfetto::protos::SchedWakeupNewFtraceEventDefaultTypeInternal121   PROTOBUF_CONSTEXPR SchedWakeupNewFtraceEventDefaultTypeInternal()
122       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedWakeupNewFtraceEventDefaultTypeInternalperfetto::protos::SchedWakeupNewFtraceEventDefaultTypeInternal123   ~SchedWakeupNewFtraceEventDefaultTypeInternal() {}
124   union {  // NOLINT(misc-non-private-member-variables-in-classes)
125     SchedWakeupNewFtraceEvent _instance;
126   };
127 };
128 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedWakeupNewFtraceEventDefaultTypeInternal _SchedWakeupNewFtraceEvent_default_instance_;
SchedProcessExecFtraceEvent(::_pbi::ConstantInitialized)129 PROTOBUF_CONSTEXPR SchedProcessExecFtraceEvent::SchedProcessExecFtraceEvent(
130     ::_pbi::ConstantInitialized): _impl_{
131     /*decltype(_impl_._has_bits_)*/{}
132   , /*decltype(_impl_._cached_size_)*/{}
133   , /*decltype(_impl_.filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
134   , /*decltype(_impl_.pid_)*/0
135   , /*decltype(_impl_.old_pid_)*/0} {}
136 struct SchedProcessExecFtraceEventDefaultTypeInternal {
SchedProcessExecFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessExecFtraceEventDefaultTypeInternal137   PROTOBUF_CONSTEXPR SchedProcessExecFtraceEventDefaultTypeInternal()
138       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedProcessExecFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessExecFtraceEventDefaultTypeInternal139   ~SchedProcessExecFtraceEventDefaultTypeInternal() {}
140   union {  // NOLINT(misc-non-private-member-variables-in-classes)
141     SchedProcessExecFtraceEvent _instance;
142   };
143 };
144 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedProcessExecFtraceEventDefaultTypeInternal _SchedProcessExecFtraceEvent_default_instance_;
SchedProcessExitFtraceEvent(::_pbi::ConstantInitialized)145 PROTOBUF_CONSTEXPR SchedProcessExitFtraceEvent::SchedProcessExitFtraceEvent(
146     ::_pbi::ConstantInitialized): _impl_{
147     /*decltype(_impl_._has_bits_)*/{}
148   , /*decltype(_impl_._cached_size_)*/{}
149   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
150   , /*decltype(_impl_.pid_)*/0
151   , /*decltype(_impl_.tgid_)*/0
152   , /*decltype(_impl_.prio_)*/0} {}
153 struct SchedProcessExitFtraceEventDefaultTypeInternal {
SchedProcessExitFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessExitFtraceEventDefaultTypeInternal154   PROTOBUF_CONSTEXPR SchedProcessExitFtraceEventDefaultTypeInternal()
155       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedProcessExitFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessExitFtraceEventDefaultTypeInternal156   ~SchedProcessExitFtraceEventDefaultTypeInternal() {}
157   union {  // NOLINT(misc-non-private-member-variables-in-classes)
158     SchedProcessExitFtraceEvent _instance;
159   };
160 };
161 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedProcessExitFtraceEventDefaultTypeInternal _SchedProcessExitFtraceEvent_default_instance_;
SchedProcessForkFtraceEvent(::_pbi::ConstantInitialized)162 PROTOBUF_CONSTEXPR SchedProcessForkFtraceEvent::SchedProcessForkFtraceEvent(
163     ::_pbi::ConstantInitialized): _impl_{
164     /*decltype(_impl_._has_bits_)*/{}
165   , /*decltype(_impl_._cached_size_)*/{}
166   , /*decltype(_impl_.parent_comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
167   , /*decltype(_impl_.child_comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
168   , /*decltype(_impl_.parent_pid_)*/0
169   , /*decltype(_impl_.child_pid_)*/0} {}
170 struct SchedProcessForkFtraceEventDefaultTypeInternal {
SchedProcessForkFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessForkFtraceEventDefaultTypeInternal171   PROTOBUF_CONSTEXPR SchedProcessForkFtraceEventDefaultTypeInternal()
172       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedProcessForkFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessForkFtraceEventDefaultTypeInternal173   ~SchedProcessForkFtraceEventDefaultTypeInternal() {}
174   union {  // NOLINT(misc-non-private-member-variables-in-classes)
175     SchedProcessForkFtraceEvent _instance;
176   };
177 };
178 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedProcessForkFtraceEventDefaultTypeInternal _SchedProcessForkFtraceEvent_default_instance_;
SchedProcessFreeFtraceEvent(::_pbi::ConstantInitialized)179 PROTOBUF_CONSTEXPR SchedProcessFreeFtraceEvent::SchedProcessFreeFtraceEvent(
180     ::_pbi::ConstantInitialized): _impl_{
181     /*decltype(_impl_._has_bits_)*/{}
182   , /*decltype(_impl_._cached_size_)*/{}
183   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
184   , /*decltype(_impl_.pid_)*/0
185   , /*decltype(_impl_.prio_)*/0} {}
186 struct SchedProcessFreeFtraceEventDefaultTypeInternal {
SchedProcessFreeFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessFreeFtraceEventDefaultTypeInternal187   PROTOBUF_CONSTEXPR SchedProcessFreeFtraceEventDefaultTypeInternal()
188       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedProcessFreeFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessFreeFtraceEventDefaultTypeInternal189   ~SchedProcessFreeFtraceEventDefaultTypeInternal() {}
190   union {  // NOLINT(misc-non-private-member-variables-in-classes)
191     SchedProcessFreeFtraceEvent _instance;
192   };
193 };
194 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedProcessFreeFtraceEventDefaultTypeInternal _SchedProcessFreeFtraceEvent_default_instance_;
SchedProcessHangFtraceEvent(::_pbi::ConstantInitialized)195 PROTOBUF_CONSTEXPR SchedProcessHangFtraceEvent::SchedProcessHangFtraceEvent(
196     ::_pbi::ConstantInitialized): _impl_{
197     /*decltype(_impl_._has_bits_)*/{}
198   , /*decltype(_impl_._cached_size_)*/{}
199   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
200   , /*decltype(_impl_.pid_)*/0} {}
201 struct SchedProcessHangFtraceEventDefaultTypeInternal {
SchedProcessHangFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessHangFtraceEventDefaultTypeInternal202   PROTOBUF_CONSTEXPR SchedProcessHangFtraceEventDefaultTypeInternal()
203       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedProcessHangFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessHangFtraceEventDefaultTypeInternal204   ~SchedProcessHangFtraceEventDefaultTypeInternal() {}
205   union {  // NOLINT(misc-non-private-member-variables-in-classes)
206     SchedProcessHangFtraceEvent _instance;
207   };
208 };
209 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedProcessHangFtraceEventDefaultTypeInternal _SchedProcessHangFtraceEvent_default_instance_;
SchedProcessWaitFtraceEvent(::_pbi::ConstantInitialized)210 PROTOBUF_CONSTEXPR SchedProcessWaitFtraceEvent::SchedProcessWaitFtraceEvent(
211     ::_pbi::ConstantInitialized): _impl_{
212     /*decltype(_impl_._has_bits_)*/{}
213   , /*decltype(_impl_._cached_size_)*/{}
214   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
215   , /*decltype(_impl_.pid_)*/0
216   , /*decltype(_impl_.prio_)*/0} {}
217 struct SchedProcessWaitFtraceEventDefaultTypeInternal {
SchedProcessWaitFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessWaitFtraceEventDefaultTypeInternal218   PROTOBUF_CONSTEXPR SchedProcessWaitFtraceEventDefaultTypeInternal()
219       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedProcessWaitFtraceEventDefaultTypeInternalperfetto::protos::SchedProcessWaitFtraceEventDefaultTypeInternal220   ~SchedProcessWaitFtraceEventDefaultTypeInternal() {}
221   union {  // NOLINT(misc-non-private-member-variables-in-classes)
222     SchedProcessWaitFtraceEvent _instance;
223   };
224 };
225 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedProcessWaitFtraceEventDefaultTypeInternal _SchedProcessWaitFtraceEvent_default_instance_;
SchedPiSetprioFtraceEvent(::_pbi::ConstantInitialized)226 PROTOBUF_CONSTEXPR SchedPiSetprioFtraceEvent::SchedPiSetprioFtraceEvent(
227     ::_pbi::ConstantInitialized): _impl_{
228     /*decltype(_impl_._has_bits_)*/{}
229   , /*decltype(_impl_._cached_size_)*/{}
230   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
231   , /*decltype(_impl_.newprio_)*/0
232   , /*decltype(_impl_.oldprio_)*/0
233   , /*decltype(_impl_.pid_)*/0} {}
234 struct SchedPiSetprioFtraceEventDefaultTypeInternal {
SchedPiSetprioFtraceEventDefaultTypeInternalperfetto::protos::SchedPiSetprioFtraceEventDefaultTypeInternal235   PROTOBUF_CONSTEXPR SchedPiSetprioFtraceEventDefaultTypeInternal()
236       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedPiSetprioFtraceEventDefaultTypeInternalperfetto::protos::SchedPiSetprioFtraceEventDefaultTypeInternal237   ~SchedPiSetprioFtraceEventDefaultTypeInternal() {}
238   union {  // NOLINT(misc-non-private-member-variables-in-classes)
239     SchedPiSetprioFtraceEvent _instance;
240   };
241 };
242 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedPiSetprioFtraceEventDefaultTypeInternal _SchedPiSetprioFtraceEvent_default_instance_;
SchedCpuUtilCfsFtraceEvent(::_pbi::ConstantInitialized)243 PROTOBUF_CONSTEXPR SchedCpuUtilCfsFtraceEvent::SchedCpuUtilCfsFtraceEvent(
244     ::_pbi::ConstantInitialized): _impl_{
245     /*decltype(_impl_._has_bits_)*/{}
246   , /*decltype(_impl_._cached_size_)*/{}
247   , /*decltype(_impl_.capacity_)*/::uint64_t{0u}
248   , /*decltype(_impl_.active_)*/0
249   , /*decltype(_impl_.cpu_)*/0u
250   , /*decltype(_impl_.capacity_orig_)*/::uint64_t{0u}
251   , /*decltype(_impl_.cpu_importance_)*/::uint64_t{0u}
252   , /*decltype(_impl_.cpu_util_)*/::uint64_t{0u}
253   , /*decltype(_impl_.group_capacity_)*/::uint64_t{0u}
254   , /*decltype(_impl_.exit_lat_)*/0u
255   , /*decltype(_impl_.grp_overutilized_)*/0u
256   , /*decltype(_impl_.idle_cpu_)*/0u
257   , /*decltype(_impl_.nr_running_)*/0u
258   , /*decltype(_impl_.spare_cap_)*/::int64_t{0}
259   , /*decltype(_impl_.wake_group_util_)*/::uint64_t{0u}
260   , /*decltype(_impl_.wake_util_)*/::uint64_t{0u}
261   , /*decltype(_impl_.task_fits_)*/0u} {}
262 struct SchedCpuUtilCfsFtraceEventDefaultTypeInternal {
SchedCpuUtilCfsFtraceEventDefaultTypeInternalperfetto::protos::SchedCpuUtilCfsFtraceEventDefaultTypeInternal263   PROTOBUF_CONSTEXPR SchedCpuUtilCfsFtraceEventDefaultTypeInternal()
264       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedCpuUtilCfsFtraceEventDefaultTypeInternalperfetto::protos::SchedCpuUtilCfsFtraceEventDefaultTypeInternal265   ~SchedCpuUtilCfsFtraceEventDefaultTypeInternal() {}
266   union {  // NOLINT(misc-non-private-member-variables-in-classes)
267     SchedCpuUtilCfsFtraceEvent _instance;
268   };
269 };
270 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedCpuUtilCfsFtraceEventDefaultTypeInternal _SchedCpuUtilCfsFtraceEvent_default_instance_;
SchedMigrateTaskFtraceEvent(::_pbi::ConstantInitialized)271 PROTOBUF_CONSTEXPR SchedMigrateTaskFtraceEvent::SchedMigrateTaskFtraceEvent(
272     ::_pbi::ConstantInitialized): _impl_{
273     /*decltype(_impl_._has_bits_)*/{}
274   , /*decltype(_impl_._cached_size_)*/{}
275   , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
276   , /*decltype(_impl_.pid_)*/0
277   , /*decltype(_impl_.prio_)*/0
278   , /*decltype(_impl_.orig_cpu_)*/0
279   , /*decltype(_impl_.dest_cpu_)*/0
280   , /*decltype(_impl_.running_)*/0
281   , /*decltype(_impl_.load_)*/0u} {}
282 struct SchedMigrateTaskFtraceEventDefaultTypeInternal {
SchedMigrateTaskFtraceEventDefaultTypeInternalperfetto::protos::SchedMigrateTaskFtraceEventDefaultTypeInternal283   PROTOBUF_CONSTEXPR SchedMigrateTaskFtraceEventDefaultTypeInternal()
284       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedMigrateTaskFtraceEventDefaultTypeInternalperfetto::protos::SchedMigrateTaskFtraceEventDefaultTypeInternal285   ~SchedMigrateTaskFtraceEventDefaultTypeInternal() {}
286   union {  // NOLINT(misc-non-private-member-variables-in-classes)
287     SchedMigrateTaskFtraceEvent _instance;
288   };
289 };
290 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedMigrateTaskFtraceEventDefaultTypeInternal _SchedMigrateTaskFtraceEvent_default_instance_;
SchedWakeupTaskAttrFtraceEvent(::_pbi::ConstantInitialized)291 PROTOBUF_CONSTEXPR SchedWakeupTaskAttrFtraceEvent::SchedWakeupTaskAttrFtraceEvent(
292     ::_pbi::ConstantInitialized): _impl_{
293     /*decltype(_impl_._has_bits_)*/{}
294   , /*decltype(_impl_._cached_size_)*/{}
295   , /*decltype(_impl_.cpu_affinity_)*/::uint64_t{0u}
296   , /*decltype(_impl_.task_util_)*/::uint64_t{0u}
297   , /*decltype(_impl_.uclamp_min_)*/::uint64_t{0u}
298   , /*decltype(_impl_.vruntime_)*/::uint64_t{0u}
299   , /*decltype(_impl_.pid_)*/0} {}
300 struct SchedWakeupTaskAttrFtraceEventDefaultTypeInternal {
SchedWakeupTaskAttrFtraceEventDefaultTypeInternalperfetto::protos::SchedWakeupTaskAttrFtraceEventDefaultTypeInternal301   PROTOBUF_CONSTEXPR SchedWakeupTaskAttrFtraceEventDefaultTypeInternal()
302       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedWakeupTaskAttrFtraceEventDefaultTypeInternalperfetto::protos::SchedWakeupTaskAttrFtraceEventDefaultTypeInternal303   ~SchedWakeupTaskAttrFtraceEventDefaultTypeInternal() {}
304   union {  // NOLINT(misc-non-private-member-variables-in-classes)
305     SchedWakeupTaskAttrFtraceEvent _instance;
306   };
307 };
308 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedWakeupTaskAttrFtraceEventDefaultTypeInternal _SchedWakeupTaskAttrFtraceEvent_default_instance_;
309 }  // namespace protos
310 }  // namespace perfetto
311 namespace perfetto {
312 namespace protos {
313 
314 // ===================================================================
315 
316 class SchedSwitchFtraceEvent::_Internal {
317  public:
318   using HasBits = decltype(std::declval<SchedSwitchFtraceEvent>()._impl_._has_bits_);
set_has_prev_comm(HasBits * has_bits)319   static void set_has_prev_comm(HasBits* has_bits) {
320     (*has_bits)[0] |= 1u;
321   }
set_has_prev_pid(HasBits * has_bits)322   static void set_has_prev_pid(HasBits* has_bits) {
323     (*has_bits)[0] |= 4u;
324   }
set_has_prev_prio(HasBits * has_bits)325   static void set_has_prev_prio(HasBits* has_bits) {
326     (*has_bits)[0] |= 8u;
327   }
set_has_prev_state(HasBits * has_bits)328   static void set_has_prev_state(HasBits* has_bits) {
329     (*has_bits)[0] |= 16u;
330   }
set_has_next_comm(HasBits * has_bits)331   static void set_has_next_comm(HasBits* has_bits) {
332     (*has_bits)[0] |= 2u;
333   }
set_has_next_pid(HasBits * has_bits)334   static void set_has_next_pid(HasBits* has_bits) {
335     (*has_bits)[0] |= 32u;
336   }
set_has_next_prio(HasBits * has_bits)337   static void set_has_next_prio(HasBits* has_bits) {
338     (*has_bits)[0] |= 64u;
339   }
340 };
341 
SchedSwitchFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)342 SchedSwitchFtraceEvent::SchedSwitchFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
343                          bool is_message_owned)
344   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
345   SharedCtor(arena, is_message_owned);
346   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedSwitchFtraceEvent)
347 }
SchedSwitchFtraceEvent(const SchedSwitchFtraceEvent & from)348 SchedSwitchFtraceEvent::SchedSwitchFtraceEvent(const SchedSwitchFtraceEvent& from)
349   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
350   SchedSwitchFtraceEvent* const _this = this; (void)_this;
351   new (&_impl_) Impl_{
352       decltype(_impl_._has_bits_){from._impl_._has_bits_}
353     , /*decltype(_impl_._cached_size_)*/{}
354     , decltype(_impl_.prev_comm_){}
355     , decltype(_impl_.next_comm_){}
356     , decltype(_impl_.prev_pid_){}
357     , decltype(_impl_.prev_prio_){}
358     , decltype(_impl_.prev_state_){}
359     , decltype(_impl_.next_pid_){}
360     , decltype(_impl_.next_prio_){}};
361 
362   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
363   _impl_.prev_comm_.InitDefault();
364   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
365     _impl_.prev_comm_.Set("", GetArenaForAllocation());
366   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
367   if (from._internal_has_prev_comm()) {
368     _this->_impl_.prev_comm_.Set(from._internal_prev_comm(),
369       _this->GetArenaForAllocation());
370   }
371   _impl_.next_comm_.InitDefault();
372   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
373     _impl_.next_comm_.Set("", GetArenaForAllocation());
374   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
375   if (from._internal_has_next_comm()) {
376     _this->_impl_.next_comm_.Set(from._internal_next_comm(),
377       _this->GetArenaForAllocation());
378   }
379   ::memcpy(&_impl_.prev_pid_, &from._impl_.prev_pid_,
380     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.next_prio_) -
381     reinterpret_cast<char*>(&_impl_.prev_pid_)) + sizeof(_impl_.next_prio_));
382   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedSwitchFtraceEvent)
383 }
384 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)385 inline void SchedSwitchFtraceEvent::SharedCtor(
386     ::_pb::Arena* arena, bool is_message_owned) {
387   (void)arena;
388   (void)is_message_owned;
389   new (&_impl_) Impl_{
390       decltype(_impl_._has_bits_){}
391     , /*decltype(_impl_._cached_size_)*/{}
392     , decltype(_impl_.prev_comm_){}
393     , decltype(_impl_.next_comm_){}
394     , decltype(_impl_.prev_pid_){0}
395     , decltype(_impl_.prev_prio_){0}
396     , decltype(_impl_.prev_state_){::int64_t{0}}
397     , decltype(_impl_.next_pid_){0}
398     , decltype(_impl_.next_prio_){0}
399   };
400   _impl_.prev_comm_.InitDefault();
401   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
402     _impl_.prev_comm_.Set("", GetArenaForAllocation());
403   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
404   _impl_.next_comm_.InitDefault();
405   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
406     _impl_.next_comm_.Set("", GetArenaForAllocation());
407   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
408 }
409 
~SchedSwitchFtraceEvent()410 SchedSwitchFtraceEvent::~SchedSwitchFtraceEvent() {
411   // @@protoc_insertion_point(destructor:perfetto.protos.SchedSwitchFtraceEvent)
412   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
413   (void)arena;
414     return;
415   }
416   SharedDtor();
417 }
418 
SharedDtor()419 inline void SchedSwitchFtraceEvent::SharedDtor() {
420   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
421   _impl_.prev_comm_.Destroy();
422   _impl_.next_comm_.Destroy();
423 }
424 
SetCachedSize(int size) const425 void SchedSwitchFtraceEvent::SetCachedSize(int size) const {
426   _impl_._cached_size_.Set(size);
427 }
428 
Clear()429 void SchedSwitchFtraceEvent::Clear() {
430 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedSwitchFtraceEvent)
431   ::uint32_t cached_has_bits = 0;
432   // Prevent compiler warnings about cached_has_bits being unused
433   (void) cached_has_bits;
434 
435   cached_has_bits = _impl_._has_bits_[0];
436   if (cached_has_bits & 0x00000003u) {
437     if (cached_has_bits & 0x00000001u) {
438       _impl_.prev_comm_.ClearNonDefaultToEmpty();
439     }
440     if (cached_has_bits & 0x00000002u) {
441       _impl_.next_comm_.ClearNonDefaultToEmpty();
442     }
443   }
444   if (cached_has_bits & 0x0000007cu) {
445     ::memset(&_impl_.prev_pid_, 0, static_cast<size_t>(
446         reinterpret_cast<char*>(&_impl_.next_prio_) -
447         reinterpret_cast<char*>(&_impl_.prev_pid_)) + sizeof(_impl_.next_prio_));
448   }
449   _impl_._has_bits_.Clear();
450   _internal_metadata_.Clear<std::string>();
451 }
452 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)453 const char* SchedSwitchFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
454 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
455   _Internal::HasBits has_bits{};
456   while (!ctx->Done(&ptr)) {
457     ::uint32_t tag;
458     ptr = ::_pbi::ReadTag(ptr, &tag);
459     switch (tag >> 3) {
460       // optional string prev_comm = 1;
461       case 1:
462         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
463           auto str = _internal_mutable_prev_comm();
464           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
465           CHK_(ptr);
466         } else {
467           goto handle_unusual;
468         }
469         continue;
470       // optional int32 prev_pid = 2;
471       case 2:
472         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
473           _Internal::set_has_prev_pid(&has_bits);
474           _impl_.prev_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
475           CHK_(ptr);
476         } else {
477           goto handle_unusual;
478         }
479         continue;
480       // optional int32 prev_prio = 3;
481       case 3:
482         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
483           _Internal::set_has_prev_prio(&has_bits);
484           _impl_.prev_prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
485           CHK_(ptr);
486         } else {
487           goto handle_unusual;
488         }
489         continue;
490       // optional int64 prev_state = 4;
491       case 4:
492         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
493           _Internal::set_has_prev_state(&has_bits);
494           _impl_.prev_state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
495           CHK_(ptr);
496         } else {
497           goto handle_unusual;
498         }
499         continue;
500       // optional string next_comm = 5;
501       case 5:
502         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
503           auto str = _internal_mutable_next_comm();
504           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
505           CHK_(ptr);
506         } else {
507           goto handle_unusual;
508         }
509         continue;
510       // optional int32 next_pid = 6;
511       case 6:
512         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
513           _Internal::set_has_next_pid(&has_bits);
514           _impl_.next_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
515           CHK_(ptr);
516         } else {
517           goto handle_unusual;
518         }
519         continue;
520       // optional int32 next_prio = 7;
521       case 7:
522         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
523           _Internal::set_has_next_prio(&has_bits);
524           _impl_.next_prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
525           CHK_(ptr);
526         } else {
527           goto handle_unusual;
528         }
529         continue;
530       default:
531         goto handle_unusual;
532     }  // switch
533   handle_unusual:
534     if ((tag == 0) || ((tag & 7) == 4)) {
535       CHK_(ptr);
536       ctx->SetLastTag(tag);
537       goto message_done;
538     }
539     ptr = UnknownFieldParse(
540         tag,
541         _internal_metadata_.mutable_unknown_fields<std::string>(),
542         ptr, ctx);
543     CHK_(ptr != nullptr);
544   }  // while
545 message_done:
546   _impl_._has_bits_.Or(has_bits);
547   return ptr;
548 failure:
549   ptr = nullptr;
550   goto message_done;
551 #undef CHK_
552 }
553 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const554 ::uint8_t* SchedSwitchFtraceEvent::_InternalSerialize(
555     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
556   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedSwitchFtraceEvent)
557   ::uint32_t cached_has_bits = 0;
558   (void) cached_has_bits;
559 
560   cached_has_bits = _impl_._has_bits_[0];
561   // optional string prev_comm = 1;
562   if (cached_has_bits & 0x00000001u) {
563     target = stream->WriteStringMaybeAliased(
564         1, this->_internal_prev_comm(), target);
565   }
566 
567   // optional int32 prev_pid = 2;
568   if (cached_has_bits & 0x00000004u) {
569     target = stream->EnsureSpace(target);
570     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_prev_pid(), target);
571   }
572 
573   // optional int32 prev_prio = 3;
574   if (cached_has_bits & 0x00000008u) {
575     target = stream->EnsureSpace(target);
576     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prev_prio(), target);
577   }
578 
579   // optional int64 prev_state = 4;
580   if (cached_has_bits & 0x00000010u) {
581     target = stream->EnsureSpace(target);
582     target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_prev_state(), target);
583   }
584 
585   // optional string next_comm = 5;
586   if (cached_has_bits & 0x00000002u) {
587     target = stream->WriteStringMaybeAliased(
588         5, this->_internal_next_comm(), target);
589   }
590 
591   // optional int32 next_pid = 6;
592   if (cached_has_bits & 0x00000020u) {
593     target = stream->EnsureSpace(target);
594     target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_next_pid(), target);
595   }
596 
597   // optional int32 next_prio = 7;
598   if (cached_has_bits & 0x00000040u) {
599     target = stream->EnsureSpace(target);
600     target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_next_prio(), target);
601   }
602 
603   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
604     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
605         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
606   }
607   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedSwitchFtraceEvent)
608   return target;
609 }
610 
ByteSizeLong() const611 size_t SchedSwitchFtraceEvent::ByteSizeLong() const {
612 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedSwitchFtraceEvent)
613   size_t total_size = 0;
614 
615   ::uint32_t cached_has_bits = 0;
616   // Prevent compiler warnings about cached_has_bits being unused
617   (void) cached_has_bits;
618 
619   cached_has_bits = _impl_._has_bits_[0];
620   if (cached_has_bits & 0x0000007fu) {
621     // optional string prev_comm = 1;
622     if (cached_has_bits & 0x00000001u) {
623       total_size += 1 +
624         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
625           this->_internal_prev_comm());
626     }
627 
628     // optional string next_comm = 5;
629     if (cached_has_bits & 0x00000002u) {
630       total_size += 1 +
631         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
632           this->_internal_next_comm());
633     }
634 
635     // optional int32 prev_pid = 2;
636     if (cached_has_bits & 0x00000004u) {
637       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prev_pid());
638     }
639 
640     // optional int32 prev_prio = 3;
641     if (cached_has_bits & 0x00000008u) {
642       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prev_prio());
643     }
644 
645     // optional int64 prev_state = 4;
646     if (cached_has_bits & 0x00000010u) {
647       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_prev_state());
648     }
649 
650     // optional int32 next_pid = 6;
651     if (cached_has_bits & 0x00000020u) {
652       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_next_pid());
653     }
654 
655     // optional int32 next_prio = 7;
656     if (cached_has_bits & 0x00000040u) {
657       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_next_prio());
658     }
659 
660   }
661   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
662     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
663   }
664   int cached_size = ::_pbi::ToCachedSize(total_size);
665   SetCachedSize(cached_size);
666   return total_size;
667 }
668 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)669 void SchedSwitchFtraceEvent::CheckTypeAndMergeFrom(
670     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
671   MergeFrom(*::_pbi::DownCast<const SchedSwitchFtraceEvent*>(
672       &from));
673 }
674 
MergeFrom(const SchedSwitchFtraceEvent & from)675 void SchedSwitchFtraceEvent::MergeFrom(const SchedSwitchFtraceEvent& from) {
676   SchedSwitchFtraceEvent* const _this = this;
677   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedSwitchFtraceEvent)
678   GOOGLE_DCHECK_NE(&from, _this);
679   ::uint32_t cached_has_bits = 0;
680   (void) cached_has_bits;
681 
682   cached_has_bits = from._impl_._has_bits_[0];
683   if (cached_has_bits & 0x0000007fu) {
684     if (cached_has_bits & 0x00000001u) {
685       _this->_internal_set_prev_comm(from._internal_prev_comm());
686     }
687     if (cached_has_bits & 0x00000002u) {
688       _this->_internal_set_next_comm(from._internal_next_comm());
689     }
690     if (cached_has_bits & 0x00000004u) {
691       _this->_impl_.prev_pid_ = from._impl_.prev_pid_;
692     }
693     if (cached_has_bits & 0x00000008u) {
694       _this->_impl_.prev_prio_ = from._impl_.prev_prio_;
695     }
696     if (cached_has_bits & 0x00000010u) {
697       _this->_impl_.prev_state_ = from._impl_.prev_state_;
698     }
699     if (cached_has_bits & 0x00000020u) {
700       _this->_impl_.next_pid_ = from._impl_.next_pid_;
701     }
702     if (cached_has_bits & 0x00000040u) {
703       _this->_impl_.next_prio_ = from._impl_.next_prio_;
704     }
705     _this->_impl_._has_bits_[0] |= cached_has_bits;
706   }
707   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
708 }
709 
CopyFrom(const SchedSwitchFtraceEvent & from)710 void SchedSwitchFtraceEvent::CopyFrom(const SchedSwitchFtraceEvent& from) {
711 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedSwitchFtraceEvent)
712   if (&from == this) return;
713   Clear();
714   MergeFrom(from);
715 }
716 
IsInitialized() const717 bool SchedSwitchFtraceEvent::IsInitialized() const {
718   return true;
719 }
720 
InternalSwap(SchedSwitchFtraceEvent * other)721 void SchedSwitchFtraceEvent::InternalSwap(SchedSwitchFtraceEvent* other) {
722   using std::swap;
723   auto* lhs_arena = GetArenaForAllocation();
724   auto* rhs_arena = other->GetArenaForAllocation();
725   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
726   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
727   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
728       &_impl_.prev_comm_, lhs_arena,
729       &other->_impl_.prev_comm_, rhs_arena
730   );
731   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
732       &_impl_.next_comm_, lhs_arena,
733       &other->_impl_.next_comm_, rhs_arena
734   );
735   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
736       PROTOBUF_FIELD_OFFSET(SchedSwitchFtraceEvent, _impl_.next_prio_)
737       + sizeof(SchedSwitchFtraceEvent::_impl_.next_prio_)  // NOLINT
738       - PROTOBUF_FIELD_OFFSET(SchedSwitchFtraceEvent, _impl_.prev_pid_)>(
739           reinterpret_cast<char*>(&_impl_.prev_pid_),
740           reinterpret_cast<char*>(&other->_impl_.prev_pid_));
741 }
742 
GetTypeName() const743 std::string SchedSwitchFtraceEvent::GetTypeName() const {
744   return "perfetto.protos.SchedSwitchFtraceEvent";
745 }
746 
747 
748 // ===================================================================
749 
750 class SchedWakeupFtraceEvent::_Internal {
751  public:
752   using HasBits = decltype(std::declval<SchedWakeupFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)753   static void set_has_comm(HasBits* has_bits) {
754     (*has_bits)[0] |= 1u;
755   }
set_has_pid(HasBits * has_bits)756   static void set_has_pid(HasBits* has_bits) {
757     (*has_bits)[0] |= 2u;
758   }
set_has_prio(HasBits * has_bits)759   static void set_has_prio(HasBits* has_bits) {
760     (*has_bits)[0] |= 4u;
761   }
set_has_success(HasBits * has_bits)762   static void set_has_success(HasBits* has_bits) {
763     (*has_bits)[0] |= 8u;
764   }
set_has_target_cpu(HasBits * has_bits)765   static void set_has_target_cpu(HasBits* has_bits) {
766     (*has_bits)[0] |= 16u;
767   }
768 };
769 
SchedWakeupFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)770 SchedWakeupFtraceEvent::SchedWakeupFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
771                          bool is_message_owned)
772   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
773   SharedCtor(arena, is_message_owned);
774   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedWakeupFtraceEvent)
775 }
SchedWakeupFtraceEvent(const SchedWakeupFtraceEvent & from)776 SchedWakeupFtraceEvent::SchedWakeupFtraceEvent(const SchedWakeupFtraceEvent& from)
777   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
778   SchedWakeupFtraceEvent* const _this = this; (void)_this;
779   new (&_impl_) Impl_{
780       decltype(_impl_._has_bits_){from._impl_._has_bits_}
781     , /*decltype(_impl_._cached_size_)*/{}
782     , decltype(_impl_.comm_){}
783     , decltype(_impl_.pid_){}
784     , decltype(_impl_.prio_){}
785     , decltype(_impl_.success_){}
786     , decltype(_impl_.target_cpu_){}};
787 
788   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
789   _impl_.comm_.InitDefault();
790   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
791     _impl_.comm_.Set("", GetArenaForAllocation());
792   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
793   if (from._internal_has_comm()) {
794     _this->_impl_.comm_.Set(from._internal_comm(),
795       _this->GetArenaForAllocation());
796   }
797   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
798     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.target_cpu_) -
799     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.target_cpu_));
800   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedWakeupFtraceEvent)
801 }
802 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)803 inline void SchedWakeupFtraceEvent::SharedCtor(
804     ::_pb::Arena* arena, bool is_message_owned) {
805   (void)arena;
806   (void)is_message_owned;
807   new (&_impl_) Impl_{
808       decltype(_impl_._has_bits_){}
809     , /*decltype(_impl_._cached_size_)*/{}
810     , decltype(_impl_.comm_){}
811     , decltype(_impl_.pid_){0}
812     , decltype(_impl_.prio_){0}
813     , decltype(_impl_.success_){0}
814     , decltype(_impl_.target_cpu_){0}
815   };
816   _impl_.comm_.InitDefault();
817   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
818     _impl_.comm_.Set("", GetArenaForAllocation());
819   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
820 }
821 
~SchedWakeupFtraceEvent()822 SchedWakeupFtraceEvent::~SchedWakeupFtraceEvent() {
823   // @@protoc_insertion_point(destructor:perfetto.protos.SchedWakeupFtraceEvent)
824   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
825   (void)arena;
826     return;
827   }
828   SharedDtor();
829 }
830 
SharedDtor()831 inline void SchedWakeupFtraceEvent::SharedDtor() {
832   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
833   _impl_.comm_.Destroy();
834 }
835 
SetCachedSize(int size) const836 void SchedWakeupFtraceEvent::SetCachedSize(int size) const {
837   _impl_._cached_size_.Set(size);
838 }
839 
Clear()840 void SchedWakeupFtraceEvent::Clear() {
841 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedWakeupFtraceEvent)
842   ::uint32_t cached_has_bits = 0;
843   // Prevent compiler warnings about cached_has_bits being unused
844   (void) cached_has_bits;
845 
846   cached_has_bits = _impl_._has_bits_[0];
847   if (cached_has_bits & 0x00000001u) {
848     _impl_.comm_.ClearNonDefaultToEmpty();
849   }
850   if (cached_has_bits & 0x0000001eu) {
851     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
852         reinterpret_cast<char*>(&_impl_.target_cpu_) -
853         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.target_cpu_));
854   }
855   _impl_._has_bits_.Clear();
856   _internal_metadata_.Clear<std::string>();
857 }
858 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)859 const char* SchedWakeupFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
860 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
861   _Internal::HasBits has_bits{};
862   while (!ctx->Done(&ptr)) {
863     ::uint32_t tag;
864     ptr = ::_pbi::ReadTag(ptr, &tag);
865     switch (tag >> 3) {
866       // optional string comm = 1;
867       case 1:
868         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
869           auto str = _internal_mutable_comm();
870           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
871           CHK_(ptr);
872         } else {
873           goto handle_unusual;
874         }
875         continue;
876       // optional int32 pid = 2;
877       case 2:
878         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
879           _Internal::set_has_pid(&has_bits);
880           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
881           CHK_(ptr);
882         } else {
883           goto handle_unusual;
884         }
885         continue;
886       // optional int32 prio = 3;
887       case 3:
888         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
889           _Internal::set_has_prio(&has_bits);
890           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
891           CHK_(ptr);
892         } else {
893           goto handle_unusual;
894         }
895         continue;
896       // optional int32 success = 4;
897       case 4:
898         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
899           _Internal::set_has_success(&has_bits);
900           _impl_.success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
901           CHK_(ptr);
902         } else {
903           goto handle_unusual;
904         }
905         continue;
906       // optional int32 target_cpu = 5;
907       case 5:
908         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
909           _Internal::set_has_target_cpu(&has_bits);
910           _impl_.target_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
911           CHK_(ptr);
912         } else {
913           goto handle_unusual;
914         }
915         continue;
916       default:
917         goto handle_unusual;
918     }  // switch
919   handle_unusual:
920     if ((tag == 0) || ((tag & 7) == 4)) {
921       CHK_(ptr);
922       ctx->SetLastTag(tag);
923       goto message_done;
924     }
925     ptr = UnknownFieldParse(
926         tag,
927         _internal_metadata_.mutable_unknown_fields<std::string>(),
928         ptr, ctx);
929     CHK_(ptr != nullptr);
930   }  // while
931 message_done:
932   _impl_._has_bits_.Or(has_bits);
933   return ptr;
934 failure:
935   ptr = nullptr;
936   goto message_done;
937 #undef CHK_
938 }
939 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const940 ::uint8_t* SchedWakeupFtraceEvent::_InternalSerialize(
941     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
942   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedWakeupFtraceEvent)
943   ::uint32_t cached_has_bits = 0;
944   (void) cached_has_bits;
945 
946   cached_has_bits = _impl_._has_bits_[0];
947   // optional string comm = 1;
948   if (cached_has_bits & 0x00000001u) {
949     target = stream->WriteStringMaybeAliased(
950         1, this->_internal_comm(), target);
951   }
952 
953   // optional int32 pid = 2;
954   if (cached_has_bits & 0x00000002u) {
955     target = stream->EnsureSpace(target);
956     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
957   }
958 
959   // optional int32 prio = 3;
960   if (cached_has_bits & 0x00000004u) {
961     target = stream->EnsureSpace(target);
962     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prio(), target);
963   }
964 
965   // optional int32 success = 4;
966   if (cached_has_bits & 0x00000008u) {
967     target = stream->EnsureSpace(target);
968     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_success(), target);
969   }
970 
971   // optional int32 target_cpu = 5;
972   if (cached_has_bits & 0x00000010u) {
973     target = stream->EnsureSpace(target);
974     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_target_cpu(), target);
975   }
976 
977   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
978     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
979         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
980   }
981   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedWakeupFtraceEvent)
982   return target;
983 }
984 
ByteSizeLong() const985 size_t SchedWakeupFtraceEvent::ByteSizeLong() const {
986 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedWakeupFtraceEvent)
987   size_t total_size = 0;
988 
989   ::uint32_t cached_has_bits = 0;
990   // Prevent compiler warnings about cached_has_bits being unused
991   (void) cached_has_bits;
992 
993   cached_has_bits = _impl_._has_bits_[0];
994   if (cached_has_bits & 0x0000001fu) {
995     // optional string comm = 1;
996     if (cached_has_bits & 0x00000001u) {
997       total_size += 1 +
998         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
999           this->_internal_comm());
1000     }
1001 
1002     // optional int32 pid = 2;
1003     if (cached_has_bits & 0x00000002u) {
1004       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
1005     }
1006 
1007     // optional int32 prio = 3;
1008     if (cached_has_bits & 0x00000004u) {
1009       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
1010     }
1011 
1012     // optional int32 success = 4;
1013     if (cached_has_bits & 0x00000008u) {
1014       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_success());
1015     }
1016 
1017     // optional int32 target_cpu = 5;
1018     if (cached_has_bits & 0x00000010u) {
1019       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_target_cpu());
1020     }
1021 
1022   }
1023   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1024     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1025   }
1026   int cached_size = ::_pbi::ToCachedSize(total_size);
1027   SetCachedSize(cached_size);
1028   return total_size;
1029 }
1030 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1031 void SchedWakeupFtraceEvent::CheckTypeAndMergeFrom(
1032     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1033   MergeFrom(*::_pbi::DownCast<const SchedWakeupFtraceEvent*>(
1034       &from));
1035 }
1036 
MergeFrom(const SchedWakeupFtraceEvent & from)1037 void SchedWakeupFtraceEvent::MergeFrom(const SchedWakeupFtraceEvent& from) {
1038   SchedWakeupFtraceEvent* const _this = this;
1039   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedWakeupFtraceEvent)
1040   GOOGLE_DCHECK_NE(&from, _this);
1041   ::uint32_t cached_has_bits = 0;
1042   (void) cached_has_bits;
1043 
1044   cached_has_bits = from._impl_._has_bits_[0];
1045   if (cached_has_bits & 0x0000001fu) {
1046     if (cached_has_bits & 0x00000001u) {
1047       _this->_internal_set_comm(from._internal_comm());
1048     }
1049     if (cached_has_bits & 0x00000002u) {
1050       _this->_impl_.pid_ = from._impl_.pid_;
1051     }
1052     if (cached_has_bits & 0x00000004u) {
1053       _this->_impl_.prio_ = from._impl_.prio_;
1054     }
1055     if (cached_has_bits & 0x00000008u) {
1056       _this->_impl_.success_ = from._impl_.success_;
1057     }
1058     if (cached_has_bits & 0x00000010u) {
1059       _this->_impl_.target_cpu_ = from._impl_.target_cpu_;
1060     }
1061     _this->_impl_._has_bits_[0] |= cached_has_bits;
1062   }
1063   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1064 }
1065 
CopyFrom(const SchedWakeupFtraceEvent & from)1066 void SchedWakeupFtraceEvent::CopyFrom(const SchedWakeupFtraceEvent& from) {
1067 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedWakeupFtraceEvent)
1068   if (&from == this) return;
1069   Clear();
1070   MergeFrom(from);
1071 }
1072 
IsInitialized() const1073 bool SchedWakeupFtraceEvent::IsInitialized() const {
1074   return true;
1075 }
1076 
InternalSwap(SchedWakeupFtraceEvent * other)1077 void SchedWakeupFtraceEvent::InternalSwap(SchedWakeupFtraceEvent* other) {
1078   using std::swap;
1079   auto* lhs_arena = GetArenaForAllocation();
1080   auto* rhs_arena = other->GetArenaForAllocation();
1081   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1082   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1083   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1084       &_impl_.comm_, lhs_arena,
1085       &other->_impl_.comm_, rhs_arena
1086   );
1087   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1088       PROTOBUF_FIELD_OFFSET(SchedWakeupFtraceEvent, _impl_.target_cpu_)
1089       + sizeof(SchedWakeupFtraceEvent::_impl_.target_cpu_)  // NOLINT
1090       - PROTOBUF_FIELD_OFFSET(SchedWakeupFtraceEvent, _impl_.pid_)>(
1091           reinterpret_cast<char*>(&_impl_.pid_),
1092           reinterpret_cast<char*>(&other->_impl_.pid_));
1093 }
1094 
GetTypeName() const1095 std::string SchedWakeupFtraceEvent::GetTypeName() const {
1096   return "perfetto.protos.SchedWakeupFtraceEvent";
1097 }
1098 
1099 
1100 // ===================================================================
1101 
1102 class SchedBlockedReasonFtraceEvent::_Internal {
1103  public:
1104   using HasBits = decltype(std::declval<SchedBlockedReasonFtraceEvent>()._impl_._has_bits_);
set_has_pid(HasBits * has_bits)1105   static void set_has_pid(HasBits* has_bits) {
1106     (*has_bits)[0] |= 2u;
1107   }
set_has_caller(HasBits * has_bits)1108   static void set_has_caller(HasBits* has_bits) {
1109     (*has_bits)[0] |= 1u;
1110   }
set_has_io_wait(HasBits * has_bits)1111   static void set_has_io_wait(HasBits* has_bits) {
1112     (*has_bits)[0] |= 4u;
1113   }
1114 };
1115 
SchedBlockedReasonFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1116 SchedBlockedReasonFtraceEvent::SchedBlockedReasonFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1117                          bool is_message_owned)
1118   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1119   SharedCtor(arena, is_message_owned);
1120   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedBlockedReasonFtraceEvent)
1121 }
SchedBlockedReasonFtraceEvent(const SchedBlockedReasonFtraceEvent & from)1122 SchedBlockedReasonFtraceEvent::SchedBlockedReasonFtraceEvent(const SchedBlockedReasonFtraceEvent& from)
1123   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1124   SchedBlockedReasonFtraceEvent* const _this = this; (void)_this;
1125   new (&_impl_) Impl_{
1126       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1127     , /*decltype(_impl_._cached_size_)*/{}
1128     , decltype(_impl_.caller_){}
1129     , decltype(_impl_.pid_){}
1130     , decltype(_impl_.io_wait_){}};
1131 
1132   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1133   ::memcpy(&_impl_.caller_, &from._impl_.caller_,
1134     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.io_wait_) -
1135     reinterpret_cast<char*>(&_impl_.caller_)) + sizeof(_impl_.io_wait_));
1136   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedBlockedReasonFtraceEvent)
1137 }
1138 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1139 inline void SchedBlockedReasonFtraceEvent::SharedCtor(
1140     ::_pb::Arena* arena, bool is_message_owned) {
1141   (void)arena;
1142   (void)is_message_owned;
1143   new (&_impl_) Impl_{
1144       decltype(_impl_._has_bits_){}
1145     , /*decltype(_impl_._cached_size_)*/{}
1146     , decltype(_impl_.caller_){::uint64_t{0u}}
1147     , decltype(_impl_.pid_){0}
1148     , decltype(_impl_.io_wait_){0u}
1149   };
1150 }
1151 
~SchedBlockedReasonFtraceEvent()1152 SchedBlockedReasonFtraceEvent::~SchedBlockedReasonFtraceEvent() {
1153   // @@protoc_insertion_point(destructor:perfetto.protos.SchedBlockedReasonFtraceEvent)
1154   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1155   (void)arena;
1156     return;
1157   }
1158   SharedDtor();
1159 }
1160 
SharedDtor()1161 inline void SchedBlockedReasonFtraceEvent::SharedDtor() {
1162   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1163 }
1164 
SetCachedSize(int size) const1165 void SchedBlockedReasonFtraceEvent::SetCachedSize(int size) const {
1166   _impl_._cached_size_.Set(size);
1167 }
1168 
Clear()1169 void SchedBlockedReasonFtraceEvent::Clear() {
1170 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedBlockedReasonFtraceEvent)
1171   ::uint32_t cached_has_bits = 0;
1172   // Prevent compiler warnings about cached_has_bits being unused
1173   (void) cached_has_bits;
1174 
1175   cached_has_bits = _impl_._has_bits_[0];
1176   if (cached_has_bits & 0x00000007u) {
1177     ::memset(&_impl_.caller_, 0, static_cast<size_t>(
1178         reinterpret_cast<char*>(&_impl_.io_wait_) -
1179         reinterpret_cast<char*>(&_impl_.caller_)) + sizeof(_impl_.io_wait_));
1180   }
1181   _impl_._has_bits_.Clear();
1182   _internal_metadata_.Clear<std::string>();
1183 }
1184 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1185 const char* SchedBlockedReasonFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1186 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1187   _Internal::HasBits has_bits{};
1188   while (!ctx->Done(&ptr)) {
1189     ::uint32_t tag;
1190     ptr = ::_pbi::ReadTag(ptr, &tag);
1191     switch (tag >> 3) {
1192       // optional int32 pid = 1;
1193       case 1:
1194         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1195           _Internal::set_has_pid(&has_bits);
1196           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1197           CHK_(ptr);
1198         } else {
1199           goto handle_unusual;
1200         }
1201         continue;
1202       // optional uint64 caller = 2;
1203       case 2:
1204         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1205           _Internal::set_has_caller(&has_bits);
1206           _impl_.caller_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1207           CHK_(ptr);
1208         } else {
1209           goto handle_unusual;
1210         }
1211         continue;
1212       // optional uint32 io_wait = 3;
1213       case 3:
1214         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1215           _Internal::set_has_io_wait(&has_bits);
1216           _impl_.io_wait_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1217           CHK_(ptr);
1218         } else {
1219           goto handle_unusual;
1220         }
1221         continue;
1222       default:
1223         goto handle_unusual;
1224     }  // switch
1225   handle_unusual:
1226     if ((tag == 0) || ((tag & 7) == 4)) {
1227       CHK_(ptr);
1228       ctx->SetLastTag(tag);
1229       goto message_done;
1230     }
1231     ptr = UnknownFieldParse(
1232         tag,
1233         _internal_metadata_.mutable_unknown_fields<std::string>(),
1234         ptr, ctx);
1235     CHK_(ptr != nullptr);
1236   }  // while
1237 message_done:
1238   _impl_._has_bits_.Or(has_bits);
1239   return ptr;
1240 failure:
1241   ptr = nullptr;
1242   goto message_done;
1243 #undef CHK_
1244 }
1245 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1246 ::uint8_t* SchedBlockedReasonFtraceEvent::_InternalSerialize(
1247     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1248   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedBlockedReasonFtraceEvent)
1249   ::uint32_t cached_has_bits = 0;
1250   (void) cached_has_bits;
1251 
1252   cached_has_bits = _impl_._has_bits_[0];
1253   // optional int32 pid = 1;
1254   if (cached_has_bits & 0x00000002u) {
1255     target = stream->EnsureSpace(target);
1256     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_pid(), target);
1257   }
1258 
1259   // optional uint64 caller = 2;
1260   if (cached_has_bits & 0x00000001u) {
1261     target = stream->EnsureSpace(target);
1262     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_caller(), target);
1263   }
1264 
1265   // optional uint32 io_wait = 3;
1266   if (cached_has_bits & 0x00000004u) {
1267     target = stream->EnsureSpace(target);
1268     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_io_wait(), target);
1269   }
1270 
1271   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1272     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1273         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1274   }
1275   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedBlockedReasonFtraceEvent)
1276   return target;
1277 }
1278 
ByteSizeLong() const1279 size_t SchedBlockedReasonFtraceEvent::ByteSizeLong() const {
1280 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedBlockedReasonFtraceEvent)
1281   size_t total_size = 0;
1282 
1283   ::uint32_t cached_has_bits = 0;
1284   // Prevent compiler warnings about cached_has_bits being unused
1285   (void) cached_has_bits;
1286 
1287   cached_has_bits = _impl_._has_bits_[0];
1288   if (cached_has_bits & 0x00000007u) {
1289     // optional uint64 caller = 2;
1290     if (cached_has_bits & 0x00000001u) {
1291       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_caller());
1292     }
1293 
1294     // optional int32 pid = 1;
1295     if (cached_has_bits & 0x00000002u) {
1296       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
1297     }
1298 
1299     // optional uint32 io_wait = 3;
1300     if (cached_has_bits & 0x00000004u) {
1301       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_io_wait());
1302     }
1303 
1304   }
1305   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1306     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1307   }
1308   int cached_size = ::_pbi::ToCachedSize(total_size);
1309   SetCachedSize(cached_size);
1310   return total_size;
1311 }
1312 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1313 void SchedBlockedReasonFtraceEvent::CheckTypeAndMergeFrom(
1314     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1315   MergeFrom(*::_pbi::DownCast<const SchedBlockedReasonFtraceEvent*>(
1316       &from));
1317 }
1318 
MergeFrom(const SchedBlockedReasonFtraceEvent & from)1319 void SchedBlockedReasonFtraceEvent::MergeFrom(const SchedBlockedReasonFtraceEvent& from) {
1320   SchedBlockedReasonFtraceEvent* const _this = this;
1321   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedBlockedReasonFtraceEvent)
1322   GOOGLE_DCHECK_NE(&from, _this);
1323   ::uint32_t cached_has_bits = 0;
1324   (void) cached_has_bits;
1325 
1326   cached_has_bits = from._impl_._has_bits_[0];
1327   if (cached_has_bits & 0x00000007u) {
1328     if (cached_has_bits & 0x00000001u) {
1329       _this->_impl_.caller_ = from._impl_.caller_;
1330     }
1331     if (cached_has_bits & 0x00000002u) {
1332       _this->_impl_.pid_ = from._impl_.pid_;
1333     }
1334     if (cached_has_bits & 0x00000004u) {
1335       _this->_impl_.io_wait_ = from._impl_.io_wait_;
1336     }
1337     _this->_impl_._has_bits_[0] |= cached_has_bits;
1338   }
1339   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1340 }
1341 
CopyFrom(const SchedBlockedReasonFtraceEvent & from)1342 void SchedBlockedReasonFtraceEvent::CopyFrom(const SchedBlockedReasonFtraceEvent& from) {
1343 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedBlockedReasonFtraceEvent)
1344   if (&from == this) return;
1345   Clear();
1346   MergeFrom(from);
1347 }
1348 
IsInitialized() const1349 bool SchedBlockedReasonFtraceEvent::IsInitialized() const {
1350   return true;
1351 }
1352 
InternalSwap(SchedBlockedReasonFtraceEvent * other)1353 void SchedBlockedReasonFtraceEvent::InternalSwap(SchedBlockedReasonFtraceEvent* other) {
1354   using std::swap;
1355   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1356   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1357   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1358       PROTOBUF_FIELD_OFFSET(SchedBlockedReasonFtraceEvent, _impl_.io_wait_)
1359       + sizeof(SchedBlockedReasonFtraceEvent::_impl_.io_wait_)  // NOLINT
1360       - PROTOBUF_FIELD_OFFSET(SchedBlockedReasonFtraceEvent, _impl_.caller_)>(
1361           reinterpret_cast<char*>(&_impl_.caller_),
1362           reinterpret_cast<char*>(&other->_impl_.caller_));
1363 }
1364 
GetTypeName() const1365 std::string SchedBlockedReasonFtraceEvent::GetTypeName() const {
1366   return "perfetto.protos.SchedBlockedReasonFtraceEvent";
1367 }
1368 
1369 
1370 // ===================================================================
1371 
1372 class SchedCpuHotplugFtraceEvent::_Internal {
1373  public:
1374   using HasBits = decltype(std::declval<SchedCpuHotplugFtraceEvent>()._impl_._has_bits_);
set_has_affected_cpu(HasBits * has_bits)1375   static void set_has_affected_cpu(HasBits* has_bits) {
1376     (*has_bits)[0] |= 1u;
1377   }
set_has_error(HasBits * has_bits)1378   static void set_has_error(HasBits* has_bits) {
1379     (*has_bits)[0] |= 2u;
1380   }
set_has_status(HasBits * has_bits)1381   static void set_has_status(HasBits* has_bits) {
1382     (*has_bits)[0] |= 4u;
1383   }
1384 };
1385 
SchedCpuHotplugFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1386 SchedCpuHotplugFtraceEvent::SchedCpuHotplugFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1387                          bool is_message_owned)
1388   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1389   SharedCtor(arena, is_message_owned);
1390   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedCpuHotplugFtraceEvent)
1391 }
SchedCpuHotplugFtraceEvent(const SchedCpuHotplugFtraceEvent & from)1392 SchedCpuHotplugFtraceEvent::SchedCpuHotplugFtraceEvent(const SchedCpuHotplugFtraceEvent& from)
1393   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1394   SchedCpuHotplugFtraceEvent* const _this = this; (void)_this;
1395   new (&_impl_) Impl_{
1396       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1397     , /*decltype(_impl_._cached_size_)*/{}
1398     , decltype(_impl_.affected_cpu_){}
1399     , decltype(_impl_.error_){}
1400     , decltype(_impl_.status_){}};
1401 
1402   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1403   ::memcpy(&_impl_.affected_cpu_, &from._impl_.affected_cpu_,
1404     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.status_) -
1405     reinterpret_cast<char*>(&_impl_.affected_cpu_)) + sizeof(_impl_.status_));
1406   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedCpuHotplugFtraceEvent)
1407 }
1408 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1409 inline void SchedCpuHotplugFtraceEvent::SharedCtor(
1410     ::_pb::Arena* arena, bool is_message_owned) {
1411   (void)arena;
1412   (void)is_message_owned;
1413   new (&_impl_) Impl_{
1414       decltype(_impl_._has_bits_){}
1415     , /*decltype(_impl_._cached_size_)*/{}
1416     , decltype(_impl_.affected_cpu_){0}
1417     , decltype(_impl_.error_){0}
1418     , decltype(_impl_.status_){0}
1419   };
1420 }
1421 
~SchedCpuHotplugFtraceEvent()1422 SchedCpuHotplugFtraceEvent::~SchedCpuHotplugFtraceEvent() {
1423   // @@protoc_insertion_point(destructor:perfetto.protos.SchedCpuHotplugFtraceEvent)
1424   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1425   (void)arena;
1426     return;
1427   }
1428   SharedDtor();
1429 }
1430 
SharedDtor()1431 inline void SchedCpuHotplugFtraceEvent::SharedDtor() {
1432   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1433 }
1434 
SetCachedSize(int size) const1435 void SchedCpuHotplugFtraceEvent::SetCachedSize(int size) const {
1436   _impl_._cached_size_.Set(size);
1437 }
1438 
Clear()1439 void SchedCpuHotplugFtraceEvent::Clear() {
1440 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedCpuHotplugFtraceEvent)
1441   ::uint32_t cached_has_bits = 0;
1442   // Prevent compiler warnings about cached_has_bits being unused
1443   (void) cached_has_bits;
1444 
1445   cached_has_bits = _impl_._has_bits_[0];
1446   if (cached_has_bits & 0x00000007u) {
1447     ::memset(&_impl_.affected_cpu_, 0, static_cast<size_t>(
1448         reinterpret_cast<char*>(&_impl_.status_) -
1449         reinterpret_cast<char*>(&_impl_.affected_cpu_)) + sizeof(_impl_.status_));
1450   }
1451   _impl_._has_bits_.Clear();
1452   _internal_metadata_.Clear<std::string>();
1453 }
1454 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1455 const char* SchedCpuHotplugFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1456 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1457   _Internal::HasBits has_bits{};
1458   while (!ctx->Done(&ptr)) {
1459     ::uint32_t tag;
1460     ptr = ::_pbi::ReadTag(ptr, &tag);
1461     switch (tag >> 3) {
1462       // optional int32 affected_cpu = 1;
1463       case 1:
1464         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1465           _Internal::set_has_affected_cpu(&has_bits);
1466           _impl_.affected_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1467           CHK_(ptr);
1468         } else {
1469           goto handle_unusual;
1470         }
1471         continue;
1472       // optional int32 error = 2;
1473       case 2:
1474         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1475           _Internal::set_has_error(&has_bits);
1476           _impl_.error_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1477           CHK_(ptr);
1478         } else {
1479           goto handle_unusual;
1480         }
1481         continue;
1482       // optional int32 status = 3;
1483       case 3:
1484         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1485           _Internal::set_has_status(&has_bits);
1486           _impl_.status_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1487           CHK_(ptr);
1488         } else {
1489           goto handle_unusual;
1490         }
1491         continue;
1492       default:
1493         goto handle_unusual;
1494     }  // switch
1495   handle_unusual:
1496     if ((tag == 0) || ((tag & 7) == 4)) {
1497       CHK_(ptr);
1498       ctx->SetLastTag(tag);
1499       goto message_done;
1500     }
1501     ptr = UnknownFieldParse(
1502         tag,
1503         _internal_metadata_.mutable_unknown_fields<std::string>(),
1504         ptr, ctx);
1505     CHK_(ptr != nullptr);
1506   }  // while
1507 message_done:
1508   _impl_._has_bits_.Or(has_bits);
1509   return ptr;
1510 failure:
1511   ptr = nullptr;
1512   goto message_done;
1513 #undef CHK_
1514 }
1515 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1516 ::uint8_t* SchedCpuHotplugFtraceEvent::_InternalSerialize(
1517     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1518   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedCpuHotplugFtraceEvent)
1519   ::uint32_t cached_has_bits = 0;
1520   (void) cached_has_bits;
1521 
1522   cached_has_bits = _impl_._has_bits_[0];
1523   // optional int32 affected_cpu = 1;
1524   if (cached_has_bits & 0x00000001u) {
1525     target = stream->EnsureSpace(target);
1526     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_affected_cpu(), target);
1527   }
1528 
1529   // optional int32 error = 2;
1530   if (cached_has_bits & 0x00000002u) {
1531     target = stream->EnsureSpace(target);
1532     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_error(), target);
1533   }
1534 
1535   // optional int32 status = 3;
1536   if (cached_has_bits & 0x00000004u) {
1537     target = stream->EnsureSpace(target);
1538     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_status(), target);
1539   }
1540 
1541   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1542     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1543         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1544   }
1545   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedCpuHotplugFtraceEvent)
1546   return target;
1547 }
1548 
ByteSizeLong() const1549 size_t SchedCpuHotplugFtraceEvent::ByteSizeLong() const {
1550 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedCpuHotplugFtraceEvent)
1551   size_t total_size = 0;
1552 
1553   ::uint32_t cached_has_bits = 0;
1554   // Prevent compiler warnings about cached_has_bits being unused
1555   (void) cached_has_bits;
1556 
1557   cached_has_bits = _impl_._has_bits_[0];
1558   if (cached_has_bits & 0x00000007u) {
1559     // optional int32 affected_cpu = 1;
1560     if (cached_has_bits & 0x00000001u) {
1561       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_affected_cpu());
1562     }
1563 
1564     // optional int32 error = 2;
1565     if (cached_has_bits & 0x00000002u) {
1566       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_error());
1567     }
1568 
1569     // optional int32 status = 3;
1570     if (cached_has_bits & 0x00000004u) {
1571       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_status());
1572     }
1573 
1574   }
1575   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1576     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1577   }
1578   int cached_size = ::_pbi::ToCachedSize(total_size);
1579   SetCachedSize(cached_size);
1580   return total_size;
1581 }
1582 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1583 void SchedCpuHotplugFtraceEvent::CheckTypeAndMergeFrom(
1584     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1585   MergeFrom(*::_pbi::DownCast<const SchedCpuHotplugFtraceEvent*>(
1586       &from));
1587 }
1588 
MergeFrom(const SchedCpuHotplugFtraceEvent & from)1589 void SchedCpuHotplugFtraceEvent::MergeFrom(const SchedCpuHotplugFtraceEvent& from) {
1590   SchedCpuHotplugFtraceEvent* const _this = this;
1591   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedCpuHotplugFtraceEvent)
1592   GOOGLE_DCHECK_NE(&from, _this);
1593   ::uint32_t cached_has_bits = 0;
1594   (void) cached_has_bits;
1595 
1596   cached_has_bits = from._impl_._has_bits_[0];
1597   if (cached_has_bits & 0x00000007u) {
1598     if (cached_has_bits & 0x00000001u) {
1599       _this->_impl_.affected_cpu_ = from._impl_.affected_cpu_;
1600     }
1601     if (cached_has_bits & 0x00000002u) {
1602       _this->_impl_.error_ = from._impl_.error_;
1603     }
1604     if (cached_has_bits & 0x00000004u) {
1605       _this->_impl_.status_ = from._impl_.status_;
1606     }
1607     _this->_impl_._has_bits_[0] |= cached_has_bits;
1608   }
1609   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1610 }
1611 
CopyFrom(const SchedCpuHotplugFtraceEvent & from)1612 void SchedCpuHotplugFtraceEvent::CopyFrom(const SchedCpuHotplugFtraceEvent& from) {
1613 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedCpuHotplugFtraceEvent)
1614   if (&from == this) return;
1615   Clear();
1616   MergeFrom(from);
1617 }
1618 
IsInitialized() const1619 bool SchedCpuHotplugFtraceEvent::IsInitialized() const {
1620   return true;
1621 }
1622 
InternalSwap(SchedCpuHotplugFtraceEvent * other)1623 void SchedCpuHotplugFtraceEvent::InternalSwap(SchedCpuHotplugFtraceEvent* other) {
1624   using std::swap;
1625   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1626   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1627   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1628       PROTOBUF_FIELD_OFFSET(SchedCpuHotplugFtraceEvent, _impl_.status_)
1629       + sizeof(SchedCpuHotplugFtraceEvent::_impl_.status_)  // NOLINT
1630       - PROTOBUF_FIELD_OFFSET(SchedCpuHotplugFtraceEvent, _impl_.affected_cpu_)>(
1631           reinterpret_cast<char*>(&_impl_.affected_cpu_),
1632           reinterpret_cast<char*>(&other->_impl_.affected_cpu_));
1633 }
1634 
GetTypeName() const1635 std::string SchedCpuHotplugFtraceEvent::GetTypeName() const {
1636   return "perfetto.protos.SchedCpuHotplugFtraceEvent";
1637 }
1638 
1639 
1640 // ===================================================================
1641 
1642 class SchedWakingFtraceEvent::_Internal {
1643  public:
1644   using HasBits = decltype(std::declval<SchedWakingFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)1645   static void set_has_comm(HasBits* has_bits) {
1646     (*has_bits)[0] |= 1u;
1647   }
set_has_pid(HasBits * has_bits)1648   static void set_has_pid(HasBits* has_bits) {
1649     (*has_bits)[0] |= 2u;
1650   }
set_has_prio(HasBits * has_bits)1651   static void set_has_prio(HasBits* has_bits) {
1652     (*has_bits)[0] |= 4u;
1653   }
set_has_success(HasBits * has_bits)1654   static void set_has_success(HasBits* has_bits) {
1655     (*has_bits)[0] |= 8u;
1656   }
set_has_target_cpu(HasBits * has_bits)1657   static void set_has_target_cpu(HasBits* has_bits) {
1658     (*has_bits)[0] |= 16u;
1659   }
1660 };
1661 
SchedWakingFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1662 SchedWakingFtraceEvent::SchedWakingFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1663                          bool is_message_owned)
1664   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1665   SharedCtor(arena, is_message_owned);
1666   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedWakingFtraceEvent)
1667 }
SchedWakingFtraceEvent(const SchedWakingFtraceEvent & from)1668 SchedWakingFtraceEvent::SchedWakingFtraceEvent(const SchedWakingFtraceEvent& from)
1669   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1670   SchedWakingFtraceEvent* const _this = this; (void)_this;
1671   new (&_impl_) Impl_{
1672       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1673     , /*decltype(_impl_._cached_size_)*/{}
1674     , decltype(_impl_.comm_){}
1675     , decltype(_impl_.pid_){}
1676     , decltype(_impl_.prio_){}
1677     , decltype(_impl_.success_){}
1678     , decltype(_impl_.target_cpu_){}};
1679 
1680   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1681   _impl_.comm_.InitDefault();
1682   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1683     _impl_.comm_.Set("", GetArenaForAllocation());
1684   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1685   if (from._internal_has_comm()) {
1686     _this->_impl_.comm_.Set(from._internal_comm(),
1687       _this->GetArenaForAllocation());
1688   }
1689   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
1690     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.target_cpu_) -
1691     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.target_cpu_));
1692   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedWakingFtraceEvent)
1693 }
1694 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1695 inline void SchedWakingFtraceEvent::SharedCtor(
1696     ::_pb::Arena* arena, bool is_message_owned) {
1697   (void)arena;
1698   (void)is_message_owned;
1699   new (&_impl_) Impl_{
1700       decltype(_impl_._has_bits_){}
1701     , /*decltype(_impl_._cached_size_)*/{}
1702     , decltype(_impl_.comm_){}
1703     , decltype(_impl_.pid_){0}
1704     , decltype(_impl_.prio_){0}
1705     , decltype(_impl_.success_){0}
1706     , decltype(_impl_.target_cpu_){0}
1707   };
1708   _impl_.comm_.InitDefault();
1709   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1710     _impl_.comm_.Set("", GetArenaForAllocation());
1711   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1712 }
1713 
~SchedWakingFtraceEvent()1714 SchedWakingFtraceEvent::~SchedWakingFtraceEvent() {
1715   // @@protoc_insertion_point(destructor:perfetto.protos.SchedWakingFtraceEvent)
1716   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1717   (void)arena;
1718     return;
1719   }
1720   SharedDtor();
1721 }
1722 
SharedDtor()1723 inline void SchedWakingFtraceEvent::SharedDtor() {
1724   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1725   _impl_.comm_.Destroy();
1726 }
1727 
SetCachedSize(int size) const1728 void SchedWakingFtraceEvent::SetCachedSize(int size) const {
1729   _impl_._cached_size_.Set(size);
1730 }
1731 
Clear()1732 void SchedWakingFtraceEvent::Clear() {
1733 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedWakingFtraceEvent)
1734   ::uint32_t cached_has_bits = 0;
1735   // Prevent compiler warnings about cached_has_bits being unused
1736   (void) cached_has_bits;
1737 
1738   cached_has_bits = _impl_._has_bits_[0];
1739   if (cached_has_bits & 0x00000001u) {
1740     _impl_.comm_.ClearNonDefaultToEmpty();
1741   }
1742   if (cached_has_bits & 0x0000001eu) {
1743     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
1744         reinterpret_cast<char*>(&_impl_.target_cpu_) -
1745         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.target_cpu_));
1746   }
1747   _impl_._has_bits_.Clear();
1748   _internal_metadata_.Clear<std::string>();
1749 }
1750 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1751 const char* SchedWakingFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1752 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1753   _Internal::HasBits has_bits{};
1754   while (!ctx->Done(&ptr)) {
1755     ::uint32_t tag;
1756     ptr = ::_pbi::ReadTag(ptr, &tag);
1757     switch (tag >> 3) {
1758       // optional string comm = 1;
1759       case 1:
1760         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1761           auto str = _internal_mutable_comm();
1762           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1763           CHK_(ptr);
1764         } else {
1765           goto handle_unusual;
1766         }
1767         continue;
1768       // optional int32 pid = 2;
1769       case 2:
1770         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1771           _Internal::set_has_pid(&has_bits);
1772           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1773           CHK_(ptr);
1774         } else {
1775           goto handle_unusual;
1776         }
1777         continue;
1778       // optional int32 prio = 3;
1779       case 3:
1780         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1781           _Internal::set_has_prio(&has_bits);
1782           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1783           CHK_(ptr);
1784         } else {
1785           goto handle_unusual;
1786         }
1787         continue;
1788       // optional int32 success = 4;
1789       case 4:
1790         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1791           _Internal::set_has_success(&has_bits);
1792           _impl_.success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1793           CHK_(ptr);
1794         } else {
1795           goto handle_unusual;
1796         }
1797         continue;
1798       // optional int32 target_cpu = 5;
1799       case 5:
1800         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1801           _Internal::set_has_target_cpu(&has_bits);
1802           _impl_.target_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1803           CHK_(ptr);
1804         } else {
1805           goto handle_unusual;
1806         }
1807         continue;
1808       default:
1809         goto handle_unusual;
1810     }  // switch
1811   handle_unusual:
1812     if ((tag == 0) || ((tag & 7) == 4)) {
1813       CHK_(ptr);
1814       ctx->SetLastTag(tag);
1815       goto message_done;
1816     }
1817     ptr = UnknownFieldParse(
1818         tag,
1819         _internal_metadata_.mutable_unknown_fields<std::string>(),
1820         ptr, ctx);
1821     CHK_(ptr != nullptr);
1822   }  // while
1823 message_done:
1824   _impl_._has_bits_.Or(has_bits);
1825   return ptr;
1826 failure:
1827   ptr = nullptr;
1828   goto message_done;
1829 #undef CHK_
1830 }
1831 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1832 ::uint8_t* SchedWakingFtraceEvent::_InternalSerialize(
1833     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1834   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedWakingFtraceEvent)
1835   ::uint32_t cached_has_bits = 0;
1836   (void) cached_has_bits;
1837 
1838   cached_has_bits = _impl_._has_bits_[0];
1839   // optional string comm = 1;
1840   if (cached_has_bits & 0x00000001u) {
1841     target = stream->WriteStringMaybeAliased(
1842         1, this->_internal_comm(), target);
1843   }
1844 
1845   // optional int32 pid = 2;
1846   if (cached_has_bits & 0x00000002u) {
1847     target = stream->EnsureSpace(target);
1848     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
1849   }
1850 
1851   // optional int32 prio = 3;
1852   if (cached_has_bits & 0x00000004u) {
1853     target = stream->EnsureSpace(target);
1854     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prio(), target);
1855   }
1856 
1857   // optional int32 success = 4;
1858   if (cached_has_bits & 0x00000008u) {
1859     target = stream->EnsureSpace(target);
1860     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_success(), target);
1861   }
1862 
1863   // optional int32 target_cpu = 5;
1864   if (cached_has_bits & 0x00000010u) {
1865     target = stream->EnsureSpace(target);
1866     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_target_cpu(), target);
1867   }
1868 
1869   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1870     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1871         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1872   }
1873   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedWakingFtraceEvent)
1874   return target;
1875 }
1876 
ByteSizeLong() const1877 size_t SchedWakingFtraceEvent::ByteSizeLong() const {
1878 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedWakingFtraceEvent)
1879   size_t total_size = 0;
1880 
1881   ::uint32_t cached_has_bits = 0;
1882   // Prevent compiler warnings about cached_has_bits being unused
1883   (void) cached_has_bits;
1884 
1885   cached_has_bits = _impl_._has_bits_[0];
1886   if (cached_has_bits & 0x0000001fu) {
1887     // optional string comm = 1;
1888     if (cached_has_bits & 0x00000001u) {
1889       total_size += 1 +
1890         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1891           this->_internal_comm());
1892     }
1893 
1894     // optional int32 pid = 2;
1895     if (cached_has_bits & 0x00000002u) {
1896       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
1897     }
1898 
1899     // optional int32 prio = 3;
1900     if (cached_has_bits & 0x00000004u) {
1901       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
1902     }
1903 
1904     // optional int32 success = 4;
1905     if (cached_has_bits & 0x00000008u) {
1906       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_success());
1907     }
1908 
1909     // optional int32 target_cpu = 5;
1910     if (cached_has_bits & 0x00000010u) {
1911       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_target_cpu());
1912     }
1913 
1914   }
1915   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1916     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1917   }
1918   int cached_size = ::_pbi::ToCachedSize(total_size);
1919   SetCachedSize(cached_size);
1920   return total_size;
1921 }
1922 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1923 void SchedWakingFtraceEvent::CheckTypeAndMergeFrom(
1924     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1925   MergeFrom(*::_pbi::DownCast<const SchedWakingFtraceEvent*>(
1926       &from));
1927 }
1928 
MergeFrom(const SchedWakingFtraceEvent & from)1929 void SchedWakingFtraceEvent::MergeFrom(const SchedWakingFtraceEvent& from) {
1930   SchedWakingFtraceEvent* const _this = this;
1931   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedWakingFtraceEvent)
1932   GOOGLE_DCHECK_NE(&from, _this);
1933   ::uint32_t cached_has_bits = 0;
1934   (void) cached_has_bits;
1935 
1936   cached_has_bits = from._impl_._has_bits_[0];
1937   if (cached_has_bits & 0x0000001fu) {
1938     if (cached_has_bits & 0x00000001u) {
1939       _this->_internal_set_comm(from._internal_comm());
1940     }
1941     if (cached_has_bits & 0x00000002u) {
1942       _this->_impl_.pid_ = from._impl_.pid_;
1943     }
1944     if (cached_has_bits & 0x00000004u) {
1945       _this->_impl_.prio_ = from._impl_.prio_;
1946     }
1947     if (cached_has_bits & 0x00000008u) {
1948       _this->_impl_.success_ = from._impl_.success_;
1949     }
1950     if (cached_has_bits & 0x00000010u) {
1951       _this->_impl_.target_cpu_ = from._impl_.target_cpu_;
1952     }
1953     _this->_impl_._has_bits_[0] |= cached_has_bits;
1954   }
1955   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1956 }
1957 
CopyFrom(const SchedWakingFtraceEvent & from)1958 void SchedWakingFtraceEvent::CopyFrom(const SchedWakingFtraceEvent& from) {
1959 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedWakingFtraceEvent)
1960   if (&from == this) return;
1961   Clear();
1962   MergeFrom(from);
1963 }
1964 
IsInitialized() const1965 bool SchedWakingFtraceEvent::IsInitialized() const {
1966   return true;
1967 }
1968 
InternalSwap(SchedWakingFtraceEvent * other)1969 void SchedWakingFtraceEvent::InternalSwap(SchedWakingFtraceEvent* other) {
1970   using std::swap;
1971   auto* lhs_arena = GetArenaForAllocation();
1972   auto* rhs_arena = other->GetArenaForAllocation();
1973   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1974   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1975   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1976       &_impl_.comm_, lhs_arena,
1977       &other->_impl_.comm_, rhs_arena
1978   );
1979   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1980       PROTOBUF_FIELD_OFFSET(SchedWakingFtraceEvent, _impl_.target_cpu_)
1981       + sizeof(SchedWakingFtraceEvent::_impl_.target_cpu_)  // NOLINT
1982       - PROTOBUF_FIELD_OFFSET(SchedWakingFtraceEvent, _impl_.pid_)>(
1983           reinterpret_cast<char*>(&_impl_.pid_),
1984           reinterpret_cast<char*>(&other->_impl_.pid_));
1985 }
1986 
GetTypeName() const1987 std::string SchedWakingFtraceEvent::GetTypeName() const {
1988   return "perfetto.protos.SchedWakingFtraceEvent";
1989 }
1990 
1991 
1992 // ===================================================================
1993 
1994 class SchedWakeupNewFtraceEvent::_Internal {
1995  public:
1996   using HasBits = decltype(std::declval<SchedWakeupNewFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)1997   static void set_has_comm(HasBits* has_bits) {
1998     (*has_bits)[0] |= 1u;
1999   }
set_has_pid(HasBits * has_bits)2000   static void set_has_pid(HasBits* has_bits) {
2001     (*has_bits)[0] |= 2u;
2002   }
set_has_prio(HasBits * has_bits)2003   static void set_has_prio(HasBits* has_bits) {
2004     (*has_bits)[0] |= 4u;
2005   }
set_has_success(HasBits * has_bits)2006   static void set_has_success(HasBits* has_bits) {
2007     (*has_bits)[0] |= 8u;
2008   }
set_has_target_cpu(HasBits * has_bits)2009   static void set_has_target_cpu(HasBits* has_bits) {
2010     (*has_bits)[0] |= 16u;
2011   }
2012 };
2013 
SchedWakeupNewFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2014 SchedWakeupNewFtraceEvent::SchedWakeupNewFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2015                          bool is_message_owned)
2016   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2017   SharedCtor(arena, is_message_owned);
2018   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedWakeupNewFtraceEvent)
2019 }
SchedWakeupNewFtraceEvent(const SchedWakeupNewFtraceEvent & from)2020 SchedWakeupNewFtraceEvent::SchedWakeupNewFtraceEvent(const SchedWakeupNewFtraceEvent& from)
2021   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2022   SchedWakeupNewFtraceEvent* const _this = this; (void)_this;
2023   new (&_impl_) Impl_{
2024       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2025     , /*decltype(_impl_._cached_size_)*/{}
2026     , decltype(_impl_.comm_){}
2027     , decltype(_impl_.pid_){}
2028     , decltype(_impl_.prio_){}
2029     , decltype(_impl_.success_){}
2030     , decltype(_impl_.target_cpu_){}};
2031 
2032   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2033   _impl_.comm_.InitDefault();
2034   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2035     _impl_.comm_.Set("", GetArenaForAllocation());
2036   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2037   if (from._internal_has_comm()) {
2038     _this->_impl_.comm_.Set(from._internal_comm(),
2039       _this->GetArenaForAllocation());
2040   }
2041   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
2042     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.target_cpu_) -
2043     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.target_cpu_));
2044   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedWakeupNewFtraceEvent)
2045 }
2046 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2047 inline void SchedWakeupNewFtraceEvent::SharedCtor(
2048     ::_pb::Arena* arena, bool is_message_owned) {
2049   (void)arena;
2050   (void)is_message_owned;
2051   new (&_impl_) Impl_{
2052       decltype(_impl_._has_bits_){}
2053     , /*decltype(_impl_._cached_size_)*/{}
2054     , decltype(_impl_.comm_){}
2055     , decltype(_impl_.pid_){0}
2056     , decltype(_impl_.prio_){0}
2057     , decltype(_impl_.success_){0}
2058     , decltype(_impl_.target_cpu_){0}
2059   };
2060   _impl_.comm_.InitDefault();
2061   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2062     _impl_.comm_.Set("", GetArenaForAllocation());
2063   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2064 }
2065 
~SchedWakeupNewFtraceEvent()2066 SchedWakeupNewFtraceEvent::~SchedWakeupNewFtraceEvent() {
2067   // @@protoc_insertion_point(destructor:perfetto.protos.SchedWakeupNewFtraceEvent)
2068   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2069   (void)arena;
2070     return;
2071   }
2072   SharedDtor();
2073 }
2074 
SharedDtor()2075 inline void SchedWakeupNewFtraceEvent::SharedDtor() {
2076   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2077   _impl_.comm_.Destroy();
2078 }
2079 
SetCachedSize(int size) const2080 void SchedWakeupNewFtraceEvent::SetCachedSize(int size) const {
2081   _impl_._cached_size_.Set(size);
2082 }
2083 
Clear()2084 void SchedWakeupNewFtraceEvent::Clear() {
2085 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedWakeupNewFtraceEvent)
2086   ::uint32_t cached_has_bits = 0;
2087   // Prevent compiler warnings about cached_has_bits being unused
2088   (void) cached_has_bits;
2089 
2090   cached_has_bits = _impl_._has_bits_[0];
2091   if (cached_has_bits & 0x00000001u) {
2092     _impl_.comm_.ClearNonDefaultToEmpty();
2093   }
2094   if (cached_has_bits & 0x0000001eu) {
2095     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
2096         reinterpret_cast<char*>(&_impl_.target_cpu_) -
2097         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.target_cpu_));
2098   }
2099   _impl_._has_bits_.Clear();
2100   _internal_metadata_.Clear<std::string>();
2101 }
2102 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2103 const char* SchedWakeupNewFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2104 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2105   _Internal::HasBits has_bits{};
2106   while (!ctx->Done(&ptr)) {
2107     ::uint32_t tag;
2108     ptr = ::_pbi::ReadTag(ptr, &tag);
2109     switch (tag >> 3) {
2110       // optional string comm = 1;
2111       case 1:
2112         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2113           auto str = _internal_mutable_comm();
2114           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2115           CHK_(ptr);
2116         } else {
2117           goto handle_unusual;
2118         }
2119         continue;
2120       // optional int32 pid = 2;
2121       case 2:
2122         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2123           _Internal::set_has_pid(&has_bits);
2124           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2125           CHK_(ptr);
2126         } else {
2127           goto handle_unusual;
2128         }
2129         continue;
2130       // optional int32 prio = 3;
2131       case 3:
2132         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2133           _Internal::set_has_prio(&has_bits);
2134           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2135           CHK_(ptr);
2136         } else {
2137           goto handle_unusual;
2138         }
2139         continue;
2140       // optional int32 success = 4;
2141       case 4:
2142         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2143           _Internal::set_has_success(&has_bits);
2144           _impl_.success_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2145           CHK_(ptr);
2146         } else {
2147           goto handle_unusual;
2148         }
2149         continue;
2150       // optional int32 target_cpu = 5;
2151       case 5:
2152         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2153           _Internal::set_has_target_cpu(&has_bits);
2154           _impl_.target_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2155           CHK_(ptr);
2156         } else {
2157           goto handle_unusual;
2158         }
2159         continue;
2160       default:
2161         goto handle_unusual;
2162     }  // switch
2163   handle_unusual:
2164     if ((tag == 0) || ((tag & 7) == 4)) {
2165       CHK_(ptr);
2166       ctx->SetLastTag(tag);
2167       goto message_done;
2168     }
2169     ptr = UnknownFieldParse(
2170         tag,
2171         _internal_metadata_.mutable_unknown_fields<std::string>(),
2172         ptr, ctx);
2173     CHK_(ptr != nullptr);
2174   }  // while
2175 message_done:
2176   _impl_._has_bits_.Or(has_bits);
2177   return ptr;
2178 failure:
2179   ptr = nullptr;
2180   goto message_done;
2181 #undef CHK_
2182 }
2183 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2184 ::uint8_t* SchedWakeupNewFtraceEvent::_InternalSerialize(
2185     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2186   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedWakeupNewFtraceEvent)
2187   ::uint32_t cached_has_bits = 0;
2188   (void) cached_has_bits;
2189 
2190   cached_has_bits = _impl_._has_bits_[0];
2191   // optional string comm = 1;
2192   if (cached_has_bits & 0x00000001u) {
2193     target = stream->WriteStringMaybeAliased(
2194         1, this->_internal_comm(), target);
2195   }
2196 
2197   // optional int32 pid = 2;
2198   if (cached_has_bits & 0x00000002u) {
2199     target = stream->EnsureSpace(target);
2200     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
2201   }
2202 
2203   // optional int32 prio = 3;
2204   if (cached_has_bits & 0x00000004u) {
2205     target = stream->EnsureSpace(target);
2206     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prio(), target);
2207   }
2208 
2209   // optional int32 success = 4;
2210   if (cached_has_bits & 0x00000008u) {
2211     target = stream->EnsureSpace(target);
2212     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_success(), target);
2213   }
2214 
2215   // optional int32 target_cpu = 5;
2216   if (cached_has_bits & 0x00000010u) {
2217     target = stream->EnsureSpace(target);
2218     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_target_cpu(), target);
2219   }
2220 
2221   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2222     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2223         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2224   }
2225   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedWakeupNewFtraceEvent)
2226   return target;
2227 }
2228 
ByteSizeLong() const2229 size_t SchedWakeupNewFtraceEvent::ByteSizeLong() const {
2230 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedWakeupNewFtraceEvent)
2231   size_t total_size = 0;
2232 
2233   ::uint32_t cached_has_bits = 0;
2234   // Prevent compiler warnings about cached_has_bits being unused
2235   (void) cached_has_bits;
2236 
2237   cached_has_bits = _impl_._has_bits_[0];
2238   if (cached_has_bits & 0x0000001fu) {
2239     // optional string comm = 1;
2240     if (cached_has_bits & 0x00000001u) {
2241       total_size += 1 +
2242         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2243           this->_internal_comm());
2244     }
2245 
2246     // optional int32 pid = 2;
2247     if (cached_has_bits & 0x00000002u) {
2248       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
2249     }
2250 
2251     // optional int32 prio = 3;
2252     if (cached_has_bits & 0x00000004u) {
2253       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
2254     }
2255 
2256     // optional int32 success = 4;
2257     if (cached_has_bits & 0x00000008u) {
2258       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_success());
2259     }
2260 
2261     // optional int32 target_cpu = 5;
2262     if (cached_has_bits & 0x00000010u) {
2263       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_target_cpu());
2264     }
2265 
2266   }
2267   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2268     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2269   }
2270   int cached_size = ::_pbi::ToCachedSize(total_size);
2271   SetCachedSize(cached_size);
2272   return total_size;
2273 }
2274 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2275 void SchedWakeupNewFtraceEvent::CheckTypeAndMergeFrom(
2276     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2277   MergeFrom(*::_pbi::DownCast<const SchedWakeupNewFtraceEvent*>(
2278       &from));
2279 }
2280 
MergeFrom(const SchedWakeupNewFtraceEvent & from)2281 void SchedWakeupNewFtraceEvent::MergeFrom(const SchedWakeupNewFtraceEvent& from) {
2282   SchedWakeupNewFtraceEvent* const _this = this;
2283   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedWakeupNewFtraceEvent)
2284   GOOGLE_DCHECK_NE(&from, _this);
2285   ::uint32_t cached_has_bits = 0;
2286   (void) cached_has_bits;
2287 
2288   cached_has_bits = from._impl_._has_bits_[0];
2289   if (cached_has_bits & 0x0000001fu) {
2290     if (cached_has_bits & 0x00000001u) {
2291       _this->_internal_set_comm(from._internal_comm());
2292     }
2293     if (cached_has_bits & 0x00000002u) {
2294       _this->_impl_.pid_ = from._impl_.pid_;
2295     }
2296     if (cached_has_bits & 0x00000004u) {
2297       _this->_impl_.prio_ = from._impl_.prio_;
2298     }
2299     if (cached_has_bits & 0x00000008u) {
2300       _this->_impl_.success_ = from._impl_.success_;
2301     }
2302     if (cached_has_bits & 0x00000010u) {
2303       _this->_impl_.target_cpu_ = from._impl_.target_cpu_;
2304     }
2305     _this->_impl_._has_bits_[0] |= cached_has_bits;
2306   }
2307   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2308 }
2309 
CopyFrom(const SchedWakeupNewFtraceEvent & from)2310 void SchedWakeupNewFtraceEvent::CopyFrom(const SchedWakeupNewFtraceEvent& from) {
2311 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedWakeupNewFtraceEvent)
2312   if (&from == this) return;
2313   Clear();
2314   MergeFrom(from);
2315 }
2316 
IsInitialized() const2317 bool SchedWakeupNewFtraceEvent::IsInitialized() const {
2318   return true;
2319 }
2320 
InternalSwap(SchedWakeupNewFtraceEvent * other)2321 void SchedWakeupNewFtraceEvent::InternalSwap(SchedWakeupNewFtraceEvent* other) {
2322   using std::swap;
2323   auto* lhs_arena = GetArenaForAllocation();
2324   auto* rhs_arena = other->GetArenaForAllocation();
2325   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2326   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2327   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2328       &_impl_.comm_, lhs_arena,
2329       &other->_impl_.comm_, rhs_arena
2330   );
2331   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2332       PROTOBUF_FIELD_OFFSET(SchedWakeupNewFtraceEvent, _impl_.target_cpu_)
2333       + sizeof(SchedWakeupNewFtraceEvent::_impl_.target_cpu_)  // NOLINT
2334       - PROTOBUF_FIELD_OFFSET(SchedWakeupNewFtraceEvent, _impl_.pid_)>(
2335           reinterpret_cast<char*>(&_impl_.pid_),
2336           reinterpret_cast<char*>(&other->_impl_.pid_));
2337 }
2338 
GetTypeName() const2339 std::string SchedWakeupNewFtraceEvent::GetTypeName() const {
2340   return "perfetto.protos.SchedWakeupNewFtraceEvent";
2341 }
2342 
2343 
2344 // ===================================================================
2345 
2346 class SchedProcessExecFtraceEvent::_Internal {
2347  public:
2348   using HasBits = decltype(std::declval<SchedProcessExecFtraceEvent>()._impl_._has_bits_);
set_has_filename(HasBits * has_bits)2349   static void set_has_filename(HasBits* has_bits) {
2350     (*has_bits)[0] |= 1u;
2351   }
set_has_pid(HasBits * has_bits)2352   static void set_has_pid(HasBits* has_bits) {
2353     (*has_bits)[0] |= 2u;
2354   }
set_has_old_pid(HasBits * has_bits)2355   static void set_has_old_pid(HasBits* has_bits) {
2356     (*has_bits)[0] |= 4u;
2357   }
2358 };
2359 
SchedProcessExecFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2360 SchedProcessExecFtraceEvent::SchedProcessExecFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2361                          bool is_message_owned)
2362   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2363   SharedCtor(arena, is_message_owned);
2364   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedProcessExecFtraceEvent)
2365 }
SchedProcessExecFtraceEvent(const SchedProcessExecFtraceEvent & from)2366 SchedProcessExecFtraceEvent::SchedProcessExecFtraceEvent(const SchedProcessExecFtraceEvent& from)
2367   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2368   SchedProcessExecFtraceEvent* const _this = this; (void)_this;
2369   new (&_impl_) Impl_{
2370       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2371     , /*decltype(_impl_._cached_size_)*/{}
2372     , decltype(_impl_.filename_){}
2373     , decltype(_impl_.pid_){}
2374     , decltype(_impl_.old_pid_){}};
2375 
2376   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2377   _impl_.filename_.InitDefault();
2378   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2379     _impl_.filename_.Set("", GetArenaForAllocation());
2380   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2381   if (from._internal_has_filename()) {
2382     _this->_impl_.filename_.Set(from._internal_filename(),
2383       _this->GetArenaForAllocation());
2384   }
2385   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
2386     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.old_pid_) -
2387     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.old_pid_));
2388   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedProcessExecFtraceEvent)
2389 }
2390 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2391 inline void SchedProcessExecFtraceEvent::SharedCtor(
2392     ::_pb::Arena* arena, bool is_message_owned) {
2393   (void)arena;
2394   (void)is_message_owned;
2395   new (&_impl_) Impl_{
2396       decltype(_impl_._has_bits_){}
2397     , /*decltype(_impl_._cached_size_)*/{}
2398     , decltype(_impl_.filename_){}
2399     , decltype(_impl_.pid_){0}
2400     , decltype(_impl_.old_pid_){0}
2401   };
2402   _impl_.filename_.InitDefault();
2403   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2404     _impl_.filename_.Set("", GetArenaForAllocation());
2405   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2406 }
2407 
~SchedProcessExecFtraceEvent()2408 SchedProcessExecFtraceEvent::~SchedProcessExecFtraceEvent() {
2409   // @@protoc_insertion_point(destructor:perfetto.protos.SchedProcessExecFtraceEvent)
2410   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2411   (void)arena;
2412     return;
2413   }
2414   SharedDtor();
2415 }
2416 
SharedDtor()2417 inline void SchedProcessExecFtraceEvent::SharedDtor() {
2418   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2419   _impl_.filename_.Destroy();
2420 }
2421 
SetCachedSize(int size) const2422 void SchedProcessExecFtraceEvent::SetCachedSize(int size) const {
2423   _impl_._cached_size_.Set(size);
2424 }
2425 
Clear()2426 void SchedProcessExecFtraceEvent::Clear() {
2427 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedProcessExecFtraceEvent)
2428   ::uint32_t cached_has_bits = 0;
2429   // Prevent compiler warnings about cached_has_bits being unused
2430   (void) cached_has_bits;
2431 
2432   cached_has_bits = _impl_._has_bits_[0];
2433   if (cached_has_bits & 0x00000001u) {
2434     _impl_.filename_.ClearNonDefaultToEmpty();
2435   }
2436   if (cached_has_bits & 0x00000006u) {
2437     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
2438         reinterpret_cast<char*>(&_impl_.old_pid_) -
2439         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.old_pid_));
2440   }
2441   _impl_._has_bits_.Clear();
2442   _internal_metadata_.Clear<std::string>();
2443 }
2444 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2445 const char* SchedProcessExecFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2446 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2447   _Internal::HasBits has_bits{};
2448   while (!ctx->Done(&ptr)) {
2449     ::uint32_t tag;
2450     ptr = ::_pbi::ReadTag(ptr, &tag);
2451     switch (tag >> 3) {
2452       // optional string filename = 1;
2453       case 1:
2454         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2455           auto str = _internal_mutable_filename();
2456           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2457           CHK_(ptr);
2458         } else {
2459           goto handle_unusual;
2460         }
2461         continue;
2462       // optional int32 pid = 2;
2463       case 2:
2464         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2465           _Internal::set_has_pid(&has_bits);
2466           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2467           CHK_(ptr);
2468         } else {
2469           goto handle_unusual;
2470         }
2471         continue;
2472       // optional int32 old_pid = 3;
2473       case 3:
2474         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2475           _Internal::set_has_old_pid(&has_bits);
2476           _impl_.old_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2477           CHK_(ptr);
2478         } else {
2479           goto handle_unusual;
2480         }
2481         continue;
2482       default:
2483         goto handle_unusual;
2484     }  // switch
2485   handle_unusual:
2486     if ((tag == 0) || ((tag & 7) == 4)) {
2487       CHK_(ptr);
2488       ctx->SetLastTag(tag);
2489       goto message_done;
2490     }
2491     ptr = UnknownFieldParse(
2492         tag,
2493         _internal_metadata_.mutable_unknown_fields<std::string>(),
2494         ptr, ctx);
2495     CHK_(ptr != nullptr);
2496   }  // while
2497 message_done:
2498   _impl_._has_bits_.Or(has_bits);
2499   return ptr;
2500 failure:
2501   ptr = nullptr;
2502   goto message_done;
2503 #undef CHK_
2504 }
2505 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2506 ::uint8_t* SchedProcessExecFtraceEvent::_InternalSerialize(
2507     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2508   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedProcessExecFtraceEvent)
2509   ::uint32_t cached_has_bits = 0;
2510   (void) cached_has_bits;
2511 
2512   cached_has_bits = _impl_._has_bits_[0];
2513   // optional string filename = 1;
2514   if (cached_has_bits & 0x00000001u) {
2515     target = stream->WriteStringMaybeAliased(
2516         1, this->_internal_filename(), target);
2517   }
2518 
2519   // optional int32 pid = 2;
2520   if (cached_has_bits & 0x00000002u) {
2521     target = stream->EnsureSpace(target);
2522     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
2523   }
2524 
2525   // optional int32 old_pid = 3;
2526   if (cached_has_bits & 0x00000004u) {
2527     target = stream->EnsureSpace(target);
2528     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_old_pid(), target);
2529   }
2530 
2531   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2532     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2533         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2534   }
2535   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedProcessExecFtraceEvent)
2536   return target;
2537 }
2538 
ByteSizeLong() const2539 size_t SchedProcessExecFtraceEvent::ByteSizeLong() const {
2540 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedProcessExecFtraceEvent)
2541   size_t total_size = 0;
2542 
2543   ::uint32_t cached_has_bits = 0;
2544   // Prevent compiler warnings about cached_has_bits being unused
2545   (void) cached_has_bits;
2546 
2547   cached_has_bits = _impl_._has_bits_[0];
2548   if (cached_has_bits & 0x00000007u) {
2549     // optional string filename = 1;
2550     if (cached_has_bits & 0x00000001u) {
2551       total_size += 1 +
2552         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2553           this->_internal_filename());
2554     }
2555 
2556     // optional int32 pid = 2;
2557     if (cached_has_bits & 0x00000002u) {
2558       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
2559     }
2560 
2561     // optional int32 old_pid = 3;
2562     if (cached_has_bits & 0x00000004u) {
2563       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_old_pid());
2564     }
2565 
2566   }
2567   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2568     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2569   }
2570   int cached_size = ::_pbi::ToCachedSize(total_size);
2571   SetCachedSize(cached_size);
2572   return total_size;
2573 }
2574 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2575 void SchedProcessExecFtraceEvent::CheckTypeAndMergeFrom(
2576     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2577   MergeFrom(*::_pbi::DownCast<const SchedProcessExecFtraceEvent*>(
2578       &from));
2579 }
2580 
MergeFrom(const SchedProcessExecFtraceEvent & from)2581 void SchedProcessExecFtraceEvent::MergeFrom(const SchedProcessExecFtraceEvent& from) {
2582   SchedProcessExecFtraceEvent* const _this = this;
2583   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedProcessExecFtraceEvent)
2584   GOOGLE_DCHECK_NE(&from, _this);
2585   ::uint32_t cached_has_bits = 0;
2586   (void) cached_has_bits;
2587 
2588   cached_has_bits = from._impl_._has_bits_[0];
2589   if (cached_has_bits & 0x00000007u) {
2590     if (cached_has_bits & 0x00000001u) {
2591       _this->_internal_set_filename(from._internal_filename());
2592     }
2593     if (cached_has_bits & 0x00000002u) {
2594       _this->_impl_.pid_ = from._impl_.pid_;
2595     }
2596     if (cached_has_bits & 0x00000004u) {
2597       _this->_impl_.old_pid_ = from._impl_.old_pid_;
2598     }
2599     _this->_impl_._has_bits_[0] |= cached_has_bits;
2600   }
2601   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2602 }
2603 
CopyFrom(const SchedProcessExecFtraceEvent & from)2604 void SchedProcessExecFtraceEvent::CopyFrom(const SchedProcessExecFtraceEvent& from) {
2605 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedProcessExecFtraceEvent)
2606   if (&from == this) return;
2607   Clear();
2608   MergeFrom(from);
2609 }
2610 
IsInitialized() const2611 bool SchedProcessExecFtraceEvent::IsInitialized() const {
2612   return true;
2613 }
2614 
InternalSwap(SchedProcessExecFtraceEvent * other)2615 void SchedProcessExecFtraceEvent::InternalSwap(SchedProcessExecFtraceEvent* other) {
2616   using std::swap;
2617   auto* lhs_arena = GetArenaForAllocation();
2618   auto* rhs_arena = other->GetArenaForAllocation();
2619   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2620   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2621   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2622       &_impl_.filename_, lhs_arena,
2623       &other->_impl_.filename_, rhs_arena
2624   );
2625   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2626       PROTOBUF_FIELD_OFFSET(SchedProcessExecFtraceEvent, _impl_.old_pid_)
2627       + sizeof(SchedProcessExecFtraceEvent::_impl_.old_pid_)  // NOLINT
2628       - PROTOBUF_FIELD_OFFSET(SchedProcessExecFtraceEvent, _impl_.pid_)>(
2629           reinterpret_cast<char*>(&_impl_.pid_),
2630           reinterpret_cast<char*>(&other->_impl_.pid_));
2631 }
2632 
GetTypeName() const2633 std::string SchedProcessExecFtraceEvent::GetTypeName() const {
2634   return "perfetto.protos.SchedProcessExecFtraceEvent";
2635 }
2636 
2637 
2638 // ===================================================================
2639 
2640 class SchedProcessExitFtraceEvent::_Internal {
2641  public:
2642   using HasBits = decltype(std::declval<SchedProcessExitFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)2643   static void set_has_comm(HasBits* has_bits) {
2644     (*has_bits)[0] |= 1u;
2645   }
set_has_pid(HasBits * has_bits)2646   static void set_has_pid(HasBits* has_bits) {
2647     (*has_bits)[0] |= 2u;
2648   }
set_has_tgid(HasBits * has_bits)2649   static void set_has_tgid(HasBits* has_bits) {
2650     (*has_bits)[0] |= 4u;
2651   }
set_has_prio(HasBits * has_bits)2652   static void set_has_prio(HasBits* has_bits) {
2653     (*has_bits)[0] |= 8u;
2654   }
2655 };
2656 
SchedProcessExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2657 SchedProcessExitFtraceEvent::SchedProcessExitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2658                          bool is_message_owned)
2659   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2660   SharedCtor(arena, is_message_owned);
2661   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedProcessExitFtraceEvent)
2662 }
SchedProcessExitFtraceEvent(const SchedProcessExitFtraceEvent & from)2663 SchedProcessExitFtraceEvent::SchedProcessExitFtraceEvent(const SchedProcessExitFtraceEvent& from)
2664   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2665   SchedProcessExitFtraceEvent* const _this = this; (void)_this;
2666   new (&_impl_) Impl_{
2667       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2668     , /*decltype(_impl_._cached_size_)*/{}
2669     , decltype(_impl_.comm_){}
2670     , decltype(_impl_.pid_){}
2671     , decltype(_impl_.tgid_){}
2672     , decltype(_impl_.prio_){}};
2673 
2674   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2675   _impl_.comm_.InitDefault();
2676   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2677     _impl_.comm_.Set("", GetArenaForAllocation());
2678   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2679   if (from._internal_has_comm()) {
2680     _this->_impl_.comm_.Set(from._internal_comm(),
2681       _this->GetArenaForAllocation());
2682   }
2683   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
2684     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
2685     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.prio_));
2686   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedProcessExitFtraceEvent)
2687 }
2688 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2689 inline void SchedProcessExitFtraceEvent::SharedCtor(
2690     ::_pb::Arena* arena, bool is_message_owned) {
2691   (void)arena;
2692   (void)is_message_owned;
2693   new (&_impl_) Impl_{
2694       decltype(_impl_._has_bits_){}
2695     , /*decltype(_impl_._cached_size_)*/{}
2696     , decltype(_impl_.comm_){}
2697     , decltype(_impl_.pid_){0}
2698     , decltype(_impl_.tgid_){0}
2699     , decltype(_impl_.prio_){0}
2700   };
2701   _impl_.comm_.InitDefault();
2702   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2703     _impl_.comm_.Set("", GetArenaForAllocation());
2704   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2705 }
2706 
~SchedProcessExitFtraceEvent()2707 SchedProcessExitFtraceEvent::~SchedProcessExitFtraceEvent() {
2708   // @@protoc_insertion_point(destructor:perfetto.protos.SchedProcessExitFtraceEvent)
2709   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2710   (void)arena;
2711     return;
2712   }
2713   SharedDtor();
2714 }
2715 
SharedDtor()2716 inline void SchedProcessExitFtraceEvent::SharedDtor() {
2717   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2718   _impl_.comm_.Destroy();
2719 }
2720 
SetCachedSize(int size) const2721 void SchedProcessExitFtraceEvent::SetCachedSize(int size) const {
2722   _impl_._cached_size_.Set(size);
2723 }
2724 
Clear()2725 void SchedProcessExitFtraceEvent::Clear() {
2726 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedProcessExitFtraceEvent)
2727   ::uint32_t cached_has_bits = 0;
2728   // Prevent compiler warnings about cached_has_bits being unused
2729   (void) cached_has_bits;
2730 
2731   cached_has_bits = _impl_._has_bits_[0];
2732   if (cached_has_bits & 0x00000001u) {
2733     _impl_.comm_.ClearNonDefaultToEmpty();
2734   }
2735   if (cached_has_bits & 0x0000000eu) {
2736     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
2737         reinterpret_cast<char*>(&_impl_.prio_) -
2738         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.prio_));
2739   }
2740   _impl_._has_bits_.Clear();
2741   _internal_metadata_.Clear<std::string>();
2742 }
2743 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2744 const char* SchedProcessExitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2745 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2746   _Internal::HasBits has_bits{};
2747   while (!ctx->Done(&ptr)) {
2748     ::uint32_t tag;
2749     ptr = ::_pbi::ReadTag(ptr, &tag);
2750     switch (tag >> 3) {
2751       // optional string comm = 1;
2752       case 1:
2753         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
2754           auto str = _internal_mutable_comm();
2755           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2756           CHK_(ptr);
2757         } else {
2758           goto handle_unusual;
2759         }
2760         continue;
2761       // optional int32 pid = 2;
2762       case 2:
2763         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2764           _Internal::set_has_pid(&has_bits);
2765           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2766           CHK_(ptr);
2767         } else {
2768           goto handle_unusual;
2769         }
2770         continue;
2771       // optional int32 tgid = 3;
2772       case 3:
2773         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2774           _Internal::set_has_tgid(&has_bits);
2775           _impl_.tgid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2776           CHK_(ptr);
2777         } else {
2778           goto handle_unusual;
2779         }
2780         continue;
2781       // optional int32 prio = 4;
2782       case 4:
2783         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2784           _Internal::set_has_prio(&has_bits);
2785           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2786           CHK_(ptr);
2787         } else {
2788           goto handle_unusual;
2789         }
2790         continue;
2791       default:
2792         goto handle_unusual;
2793     }  // switch
2794   handle_unusual:
2795     if ((tag == 0) || ((tag & 7) == 4)) {
2796       CHK_(ptr);
2797       ctx->SetLastTag(tag);
2798       goto message_done;
2799     }
2800     ptr = UnknownFieldParse(
2801         tag,
2802         _internal_metadata_.mutable_unknown_fields<std::string>(),
2803         ptr, ctx);
2804     CHK_(ptr != nullptr);
2805   }  // while
2806 message_done:
2807   _impl_._has_bits_.Or(has_bits);
2808   return ptr;
2809 failure:
2810   ptr = nullptr;
2811   goto message_done;
2812 #undef CHK_
2813 }
2814 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2815 ::uint8_t* SchedProcessExitFtraceEvent::_InternalSerialize(
2816     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2817   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedProcessExitFtraceEvent)
2818   ::uint32_t cached_has_bits = 0;
2819   (void) cached_has_bits;
2820 
2821   cached_has_bits = _impl_._has_bits_[0];
2822   // optional string comm = 1;
2823   if (cached_has_bits & 0x00000001u) {
2824     target = stream->WriteStringMaybeAliased(
2825         1, this->_internal_comm(), target);
2826   }
2827 
2828   // optional int32 pid = 2;
2829   if (cached_has_bits & 0x00000002u) {
2830     target = stream->EnsureSpace(target);
2831     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
2832   }
2833 
2834   // optional int32 tgid = 3;
2835   if (cached_has_bits & 0x00000004u) {
2836     target = stream->EnsureSpace(target);
2837     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_tgid(), target);
2838   }
2839 
2840   // optional int32 prio = 4;
2841   if (cached_has_bits & 0x00000008u) {
2842     target = stream->EnsureSpace(target);
2843     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_prio(), target);
2844   }
2845 
2846   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2847     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2848         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2849   }
2850   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedProcessExitFtraceEvent)
2851   return target;
2852 }
2853 
ByteSizeLong() const2854 size_t SchedProcessExitFtraceEvent::ByteSizeLong() const {
2855 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedProcessExitFtraceEvent)
2856   size_t total_size = 0;
2857 
2858   ::uint32_t cached_has_bits = 0;
2859   // Prevent compiler warnings about cached_has_bits being unused
2860   (void) cached_has_bits;
2861 
2862   cached_has_bits = _impl_._has_bits_[0];
2863   if (cached_has_bits & 0x0000000fu) {
2864     // optional string comm = 1;
2865     if (cached_has_bits & 0x00000001u) {
2866       total_size += 1 +
2867         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2868           this->_internal_comm());
2869     }
2870 
2871     // optional int32 pid = 2;
2872     if (cached_has_bits & 0x00000002u) {
2873       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
2874     }
2875 
2876     // optional int32 tgid = 3;
2877     if (cached_has_bits & 0x00000004u) {
2878       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_tgid());
2879     }
2880 
2881     // optional int32 prio = 4;
2882     if (cached_has_bits & 0x00000008u) {
2883       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
2884     }
2885 
2886   }
2887   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2888     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2889   }
2890   int cached_size = ::_pbi::ToCachedSize(total_size);
2891   SetCachedSize(cached_size);
2892   return total_size;
2893 }
2894 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2895 void SchedProcessExitFtraceEvent::CheckTypeAndMergeFrom(
2896     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2897   MergeFrom(*::_pbi::DownCast<const SchedProcessExitFtraceEvent*>(
2898       &from));
2899 }
2900 
MergeFrom(const SchedProcessExitFtraceEvent & from)2901 void SchedProcessExitFtraceEvent::MergeFrom(const SchedProcessExitFtraceEvent& from) {
2902   SchedProcessExitFtraceEvent* const _this = this;
2903   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedProcessExitFtraceEvent)
2904   GOOGLE_DCHECK_NE(&from, _this);
2905   ::uint32_t cached_has_bits = 0;
2906   (void) cached_has_bits;
2907 
2908   cached_has_bits = from._impl_._has_bits_[0];
2909   if (cached_has_bits & 0x0000000fu) {
2910     if (cached_has_bits & 0x00000001u) {
2911       _this->_internal_set_comm(from._internal_comm());
2912     }
2913     if (cached_has_bits & 0x00000002u) {
2914       _this->_impl_.pid_ = from._impl_.pid_;
2915     }
2916     if (cached_has_bits & 0x00000004u) {
2917       _this->_impl_.tgid_ = from._impl_.tgid_;
2918     }
2919     if (cached_has_bits & 0x00000008u) {
2920       _this->_impl_.prio_ = from._impl_.prio_;
2921     }
2922     _this->_impl_._has_bits_[0] |= cached_has_bits;
2923   }
2924   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2925 }
2926 
CopyFrom(const SchedProcessExitFtraceEvent & from)2927 void SchedProcessExitFtraceEvent::CopyFrom(const SchedProcessExitFtraceEvent& from) {
2928 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedProcessExitFtraceEvent)
2929   if (&from == this) return;
2930   Clear();
2931   MergeFrom(from);
2932 }
2933 
IsInitialized() const2934 bool SchedProcessExitFtraceEvent::IsInitialized() const {
2935   return true;
2936 }
2937 
InternalSwap(SchedProcessExitFtraceEvent * other)2938 void SchedProcessExitFtraceEvent::InternalSwap(SchedProcessExitFtraceEvent* other) {
2939   using std::swap;
2940   auto* lhs_arena = GetArenaForAllocation();
2941   auto* rhs_arena = other->GetArenaForAllocation();
2942   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2943   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2944   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2945       &_impl_.comm_, lhs_arena,
2946       &other->_impl_.comm_, rhs_arena
2947   );
2948   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2949       PROTOBUF_FIELD_OFFSET(SchedProcessExitFtraceEvent, _impl_.prio_)
2950       + sizeof(SchedProcessExitFtraceEvent::_impl_.prio_)  // NOLINT
2951       - PROTOBUF_FIELD_OFFSET(SchedProcessExitFtraceEvent, _impl_.pid_)>(
2952           reinterpret_cast<char*>(&_impl_.pid_),
2953           reinterpret_cast<char*>(&other->_impl_.pid_));
2954 }
2955 
GetTypeName() const2956 std::string SchedProcessExitFtraceEvent::GetTypeName() const {
2957   return "perfetto.protos.SchedProcessExitFtraceEvent";
2958 }
2959 
2960 
2961 // ===================================================================
2962 
2963 class SchedProcessForkFtraceEvent::_Internal {
2964  public:
2965   using HasBits = decltype(std::declval<SchedProcessForkFtraceEvent>()._impl_._has_bits_);
set_has_parent_comm(HasBits * has_bits)2966   static void set_has_parent_comm(HasBits* has_bits) {
2967     (*has_bits)[0] |= 1u;
2968   }
set_has_parent_pid(HasBits * has_bits)2969   static void set_has_parent_pid(HasBits* has_bits) {
2970     (*has_bits)[0] |= 4u;
2971   }
set_has_child_comm(HasBits * has_bits)2972   static void set_has_child_comm(HasBits* has_bits) {
2973     (*has_bits)[0] |= 2u;
2974   }
set_has_child_pid(HasBits * has_bits)2975   static void set_has_child_pid(HasBits* has_bits) {
2976     (*has_bits)[0] |= 8u;
2977   }
2978 };
2979 
SchedProcessForkFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2980 SchedProcessForkFtraceEvent::SchedProcessForkFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2981                          bool is_message_owned)
2982   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2983   SharedCtor(arena, is_message_owned);
2984   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedProcessForkFtraceEvent)
2985 }
SchedProcessForkFtraceEvent(const SchedProcessForkFtraceEvent & from)2986 SchedProcessForkFtraceEvent::SchedProcessForkFtraceEvent(const SchedProcessForkFtraceEvent& from)
2987   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2988   SchedProcessForkFtraceEvent* const _this = this; (void)_this;
2989   new (&_impl_) Impl_{
2990       decltype(_impl_._has_bits_){from._impl_._has_bits_}
2991     , /*decltype(_impl_._cached_size_)*/{}
2992     , decltype(_impl_.parent_comm_){}
2993     , decltype(_impl_.child_comm_){}
2994     , decltype(_impl_.parent_pid_){}
2995     , decltype(_impl_.child_pid_){}};
2996 
2997   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2998   _impl_.parent_comm_.InitDefault();
2999   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3000     _impl_.parent_comm_.Set("", GetArenaForAllocation());
3001   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3002   if (from._internal_has_parent_comm()) {
3003     _this->_impl_.parent_comm_.Set(from._internal_parent_comm(),
3004       _this->GetArenaForAllocation());
3005   }
3006   _impl_.child_comm_.InitDefault();
3007   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3008     _impl_.child_comm_.Set("", GetArenaForAllocation());
3009   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3010   if (from._internal_has_child_comm()) {
3011     _this->_impl_.child_comm_.Set(from._internal_child_comm(),
3012       _this->GetArenaForAllocation());
3013   }
3014   ::memcpy(&_impl_.parent_pid_, &from._impl_.parent_pid_,
3015     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.child_pid_) -
3016     reinterpret_cast<char*>(&_impl_.parent_pid_)) + sizeof(_impl_.child_pid_));
3017   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedProcessForkFtraceEvent)
3018 }
3019 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3020 inline void SchedProcessForkFtraceEvent::SharedCtor(
3021     ::_pb::Arena* arena, bool is_message_owned) {
3022   (void)arena;
3023   (void)is_message_owned;
3024   new (&_impl_) Impl_{
3025       decltype(_impl_._has_bits_){}
3026     , /*decltype(_impl_._cached_size_)*/{}
3027     , decltype(_impl_.parent_comm_){}
3028     , decltype(_impl_.child_comm_){}
3029     , decltype(_impl_.parent_pid_){0}
3030     , decltype(_impl_.child_pid_){0}
3031   };
3032   _impl_.parent_comm_.InitDefault();
3033   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3034     _impl_.parent_comm_.Set("", GetArenaForAllocation());
3035   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3036   _impl_.child_comm_.InitDefault();
3037   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3038     _impl_.child_comm_.Set("", GetArenaForAllocation());
3039   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3040 }
3041 
~SchedProcessForkFtraceEvent()3042 SchedProcessForkFtraceEvent::~SchedProcessForkFtraceEvent() {
3043   // @@protoc_insertion_point(destructor:perfetto.protos.SchedProcessForkFtraceEvent)
3044   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3045   (void)arena;
3046     return;
3047   }
3048   SharedDtor();
3049 }
3050 
SharedDtor()3051 inline void SchedProcessForkFtraceEvent::SharedDtor() {
3052   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3053   _impl_.parent_comm_.Destroy();
3054   _impl_.child_comm_.Destroy();
3055 }
3056 
SetCachedSize(int size) const3057 void SchedProcessForkFtraceEvent::SetCachedSize(int size) const {
3058   _impl_._cached_size_.Set(size);
3059 }
3060 
Clear()3061 void SchedProcessForkFtraceEvent::Clear() {
3062 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedProcessForkFtraceEvent)
3063   ::uint32_t cached_has_bits = 0;
3064   // Prevent compiler warnings about cached_has_bits being unused
3065   (void) cached_has_bits;
3066 
3067   cached_has_bits = _impl_._has_bits_[0];
3068   if (cached_has_bits & 0x00000003u) {
3069     if (cached_has_bits & 0x00000001u) {
3070       _impl_.parent_comm_.ClearNonDefaultToEmpty();
3071     }
3072     if (cached_has_bits & 0x00000002u) {
3073       _impl_.child_comm_.ClearNonDefaultToEmpty();
3074     }
3075   }
3076   if (cached_has_bits & 0x0000000cu) {
3077     ::memset(&_impl_.parent_pid_, 0, static_cast<size_t>(
3078         reinterpret_cast<char*>(&_impl_.child_pid_) -
3079         reinterpret_cast<char*>(&_impl_.parent_pid_)) + sizeof(_impl_.child_pid_));
3080   }
3081   _impl_._has_bits_.Clear();
3082   _internal_metadata_.Clear<std::string>();
3083 }
3084 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3085 const char* SchedProcessForkFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3086 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3087   _Internal::HasBits has_bits{};
3088   while (!ctx->Done(&ptr)) {
3089     ::uint32_t tag;
3090     ptr = ::_pbi::ReadTag(ptr, &tag);
3091     switch (tag >> 3) {
3092       // optional string parent_comm = 1;
3093       case 1:
3094         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3095           auto str = _internal_mutable_parent_comm();
3096           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3097           CHK_(ptr);
3098         } else {
3099           goto handle_unusual;
3100         }
3101         continue;
3102       // optional int32 parent_pid = 2;
3103       case 2:
3104         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3105           _Internal::set_has_parent_pid(&has_bits);
3106           _impl_.parent_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3107           CHK_(ptr);
3108         } else {
3109           goto handle_unusual;
3110         }
3111         continue;
3112       // optional string child_comm = 3;
3113       case 3:
3114         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
3115           auto str = _internal_mutable_child_comm();
3116           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3117           CHK_(ptr);
3118         } else {
3119           goto handle_unusual;
3120         }
3121         continue;
3122       // optional int32 child_pid = 4;
3123       case 4:
3124         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3125           _Internal::set_has_child_pid(&has_bits);
3126           _impl_.child_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3127           CHK_(ptr);
3128         } else {
3129           goto handle_unusual;
3130         }
3131         continue;
3132       default:
3133         goto handle_unusual;
3134     }  // switch
3135   handle_unusual:
3136     if ((tag == 0) || ((tag & 7) == 4)) {
3137       CHK_(ptr);
3138       ctx->SetLastTag(tag);
3139       goto message_done;
3140     }
3141     ptr = UnknownFieldParse(
3142         tag,
3143         _internal_metadata_.mutable_unknown_fields<std::string>(),
3144         ptr, ctx);
3145     CHK_(ptr != nullptr);
3146   }  // while
3147 message_done:
3148   _impl_._has_bits_.Or(has_bits);
3149   return ptr;
3150 failure:
3151   ptr = nullptr;
3152   goto message_done;
3153 #undef CHK_
3154 }
3155 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3156 ::uint8_t* SchedProcessForkFtraceEvent::_InternalSerialize(
3157     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3158   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedProcessForkFtraceEvent)
3159   ::uint32_t cached_has_bits = 0;
3160   (void) cached_has_bits;
3161 
3162   cached_has_bits = _impl_._has_bits_[0];
3163   // optional string parent_comm = 1;
3164   if (cached_has_bits & 0x00000001u) {
3165     target = stream->WriteStringMaybeAliased(
3166         1, this->_internal_parent_comm(), target);
3167   }
3168 
3169   // optional int32 parent_pid = 2;
3170   if (cached_has_bits & 0x00000004u) {
3171     target = stream->EnsureSpace(target);
3172     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_parent_pid(), target);
3173   }
3174 
3175   // optional string child_comm = 3;
3176   if (cached_has_bits & 0x00000002u) {
3177     target = stream->WriteStringMaybeAliased(
3178         3, this->_internal_child_comm(), target);
3179   }
3180 
3181   // optional int32 child_pid = 4;
3182   if (cached_has_bits & 0x00000008u) {
3183     target = stream->EnsureSpace(target);
3184     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_child_pid(), target);
3185   }
3186 
3187   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3188     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3189         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3190   }
3191   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedProcessForkFtraceEvent)
3192   return target;
3193 }
3194 
ByteSizeLong() const3195 size_t SchedProcessForkFtraceEvent::ByteSizeLong() const {
3196 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedProcessForkFtraceEvent)
3197   size_t total_size = 0;
3198 
3199   ::uint32_t cached_has_bits = 0;
3200   // Prevent compiler warnings about cached_has_bits being unused
3201   (void) cached_has_bits;
3202 
3203   cached_has_bits = _impl_._has_bits_[0];
3204   if (cached_has_bits & 0x0000000fu) {
3205     // optional string parent_comm = 1;
3206     if (cached_has_bits & 0x00000001u) {
3207       total_size += 1 +
3208         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3209           this->_internal_parent_comm());
3210     }
3211 
3212     // optional string child_comm = 3;
3213     if (cached_has_bits & 0x00000002u) {
3214       total_size += 1 +
3215         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3216           this->_internal_child_comm());
3217     }
3218 
3219     // optional int32 parent_pid = 2;
3220     if (cached_has_bits & 0x00000004u) {
3221       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_parent_pid());
3222     }
3223 
3224     // optional int32 child_pid = 4;
3225     if (cached_has_bits & 0x00000008u) {
3226       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_child_pid());
3227     }
3228 
3229   }
3230   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3231     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3232   }
3233   int cached_size = ::_pbi::ToCachedSize(total_size);
3234   SetCachedSize(cached_size);
3235   return total_size;
3236 }
3237 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3238 void SchedProcessForkFtraceEvent::CheckTypeAndMergeFrom(
3239     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3240   MergeFrom(*::_pbi::DownCast<const SchedProcessForkFtraceEvent*>(
3241       &from));
3242 }
3243 
MergeFrom(const SchedProcessForkFtraceEvent & from)3244 void SchedProcessForkFtraceEvent::MergeFrom(const SchedProcessForkFtraceEvent& from) {
3245   SchedProcessForkFtraceEvent* const _this = this;
3246   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedProcessForkFtraceEvent)
3247   GOOGLE_DCHECK_NE(&from, _this);
3248   ::uint32_t cached_has_bits = 0;
3249   (void) cached_has_bits;
3250 
3251   cached_has_bits = from._impl_._has_bits_[0];
3252   if (cached_has_bits & 0x0000000fu) {
3253     if (cached_has_bits & 0x00000001u) {
3254       _this->_internal_set_parent_comm(from._internal_parent_comm());
3255     }
3256     if (cached_has_bits & 0x00000002u) {
3257       _this->_internal_set_child_comm(from._internal_child_comm());
3258     }
3259     if (cached_has_bits & 0x00000004u) {
3260       _this->_impl_.parent_pid_ = from._impl_.parent_pid_;
3261     }
3262     if (cached_has_bits & 0x00000008u) {
3263       _this->_impl_.child_pid_ = from._impl_.child_pid_;
3264     }
3265     _this->_impl_._has_bits_[0] |= cached_has_bits;
3266   }
3267   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3268 }
3269 
CopyFrom(const SchedProcessForkFtraceEvent & from)3270 void SchedProcessForkFtraceEvent::CopyFrom(const SchedProcessForkFtraceEvent& from) {
3271 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedProcessForkFtraceEvent)
3272   if (&from == this) return;
3273   Clear();
3274   MergeFrom(from);
3275 }
3276 
IsInitialized() const3277 bool SchedProcessForkFtraceEvent::IsInitialized() const {
3278   return true;
3279 }
3280 
InternalSwap(SchedProcessForkFtraceEvent * other)3281 void SchedProcessForkFtraceEvent::InternalSwap(SchedProcessForkFtraceEvent* other) {
3282   using std::swap;
3283   auto* lhs_arena = GetArenaForAllocation();
3284   auto* rhs_arena = other->GetArenaForAllocation();
3285   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3286   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3287   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3288       &_impl_.parent_comm_, lhs_arena,
3289       &other->_impl_.parent_comm_, rhs_arena
3290   );
3291   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3292       &_impl_.child_comm_, lhs_arena,
3293       &other->_impl_.child_comm_, rhs_arena
3294   );
3295   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3296       PROTOBUF_FIELD_OFFSET(SchedProcessForkFtraceEvent, _impl_.child_pid_)
3297       + sizeof(SchedProcessForkFtraceEvent::_impl_.child_pid_)  // NOLINT
3298       - PROTOBUF_FIELD_OFFSET(SchedProcessForkFtraceEvent, _impl_.parent_pid_)>(
3299           reinterpret_cast<char*>(&_impl_.parent_pid_),
3300           reinterpret_cast<char*>(&other->_impl_.parent_pid_));
3301 }
3302 
GetTypeName() const3303 std::string SchedProcessForkFtraceEvent::GetTypeName() const {
3304   return "perfetto.protos.SchedProcessForkFtraceEvent";
3305 }
3306 
3307 
3308 // ===================================================================
3309 
3310 class SchedProcessFreeFtraceEvent::_Internal {
3311  public:
3312   using HasBits = decltype(std::declval<SchedProcessFreeFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)3313   static void set_has_comm(HasBits* has_bits) {
3314     (*has_bits)[0] |= 1u;
3315   }
set_has_pid(HasBits * has_bits)3316   static void set_has_pid(HasBits* has_bits) {
3317     (*has_bits)[0] |= 2u;
3318   }
set_has_prio(HasBits * has_bits)3319   static void set_has_prio(HasBits* has_bits) {
3320     (*has_bits)[0] |= 4u;
3321   }
3322 };
3323 
SchedProcessFreeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3324 SchedProcessFreeFtraceEvent::SchedProcessFreeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3325                          bool is_message_owned)
3326   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3327   SharedCtor(arena, is_message_owned);
3328   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedProcessFreeFtraceEvent)
3329 }
SchedProcessFreeFtraceEvent(const SchedProcessFreeFtraceEvent & from)3330 SchedProcessFreeFtraceEvent::SchedProcessFreeFtraceEvent(const SchedProcessFreeFtraceEvent& from)
3331   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3332   SchedProcessFreeFtraceEvent* const _this = this; (void)_this;
3333   new (&_impl_) Impl_{
3334       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3335     , /*decltype(_impl_._cached_size_)*/{}
3336     , decltype(_impl_.comm_){}
3337     , decltype(_impl_.pid_){}
3338     , decltype(_impl_.prio_){}};
3339 
3340   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3341   _impl_.comm_.InitDefault();
3342   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3343     _impl_.comm_.Set("", GetArenaForAllocation());
3344   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3345   if (from._internal_has_comm()) {
3346     _this->_impl_.comm_.Set(from._internal_comm(),
3347       _this->GetArenaForAllocation());
3348   }
3349   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
3350     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
3351     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.prio_));
3352   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedProcessFreeFtraceEvent)
3353 }
3354 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3355 inline void SchedProcessFreeFtraceEvent::SharedCtor(
3356     ::_pb::Arena* arena, bool is_message_owned) {
3357   (void)arena;
3358   (void)is_message_owned;
3359   new (&_impl_) Impl_{
3360       decltype(_impl_._has_bits_){}
3361     , /*decltype(_impl_._cached_size_)*/{}
3362     , decltype(_impl_.comm_){}
3363     , decltype(_impl_.pid_){0}
3364     , decltype(_impl_.prio_){0}
3365   };
3366   _impl_.comm_.InitDefault();
3367   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3368     _impl_.comm_.Set("", GetArenaForAllocation());
3369   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3370 }
3371 
~SchedProcessFreeFtraceEvent()3372 SchedProcessFreeFtraceEvent::~SchedProcessFreeFtraceEvent() {
3373   // @@protoc_insertion_point(destructor:perfetto.protos.SchedProcessFreeFtraceEvent)
3374   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3375   (void)arena;
3376     return;
3377   }
3378   SharedDtor();
3379 }
3380 
SharedDtor()3381 inline void SchedProcessFreeFtraceEvent::SharedDtor() {
3382   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3383   _impl_.comm_.Destroy();
3384 }
3385 
SetCachedSize(int size) const3386 void SchedProcessFreeFtraceEvent::SetCachedSize(int size) const {
3387   _impl_._cached_size_.Set(size);
3388 }
3389 
Clear()3390 void SchedProcessFreeFtraceEvent::Clear() {
3391 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedProcessFreeFtraceEvent)
3392   ::uint32_t cached_has_bits = 0;
3393   // Prevent compiler warnings about cached_has_bits being unused
3394   (void) cached_has_bits;
3395 
3396   cached_has_bits = _impl_._has_bits_[0];
3397   if (cached_has_bits & 0x00000001u) {
3398     _impl_.comm_.ClearNonDefaultToEmpty();
3399   }
3400   if (cached_has_bits & 0x00000006u) {
3401     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
3402         reinterpret_cast<char*>(&_impl_.prio_) -
3403         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.prio_));
3404   }
3405   _impl_._has_bits_.Clear();
3406   _internal_metadata_.Clear<std::string>();
3407 }
3408 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3409 const char* SchedProcessFreeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3410 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3411   _Internal::HasBits has_bits{};
3412   while (!ctx->Done(&ptr)) {
3413     ::uint32_t tag;
3414     ptr = ::_pbi::ReadTag(ptr, &tag);
3415     switch (tag >> 3) {
3416       // optional string comm = 1;
3417       case 1:
3418         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3419           auto str = _internal_mutable_comm();
3420           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3421           CHK_(ptr);
3422         } else {
3423           goto handle_unusual;
3424         }
3425         continue;
3426       // optional int32 pid = 2;
3427       case 2:
3428         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3429           _Internal::set_has_pid(&has_bits);
3430           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3431           CHK_(ptr);
3432         } else {
3433           goto handle_unusual;
3434         }
3435         continue;
3436       // optional int32 prio = 3;
3437       case 3:
3438         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3439           _Internal::set_has_prio(&has_bits);
3440           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3441           CHK_(ptr);
3442         } else {
3443           goto handle_unusual;
3444         }
3445         continue;
3446       default:
3447         goto handle_unusual;
3448     }  // switch
3449   handle_unusual:
3450     if ((tag == 0) || ((tag & 7) == 4)) {
3451       CHK_(ptr);
3452       ctx->SetLastTag(tag);
3453       goto message_done;
3454     }
3455     ptr = UnknownFieldParse(
3456         tag,
3457         _internal_metadata_.mutable_unknown_fields<std::string>(),
3458         ptr, ctx);
3459     CHK_(ptr != nullptr);
3460   }  // while
3461 message_done:
3462   _impl_._has_bits_.Or(has_bits);
3463   return ptr;
3464 failure:
3465   ptr = nullptr;
3466   goto message_done;
3467 #undef CHK_
3468 }
3469 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3470 ::uint8_t* SchedProcessFreeFtraceEvent::_InternalSerialize(
3471     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3472   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedProcessFreeFtraceEvent)
3473   ::uint32_t cached_has_bits = 0;
3474   (void) cached_has_bits;
3475 
3476   cached_has_bits = _impl_._has_bits_[0];
3477   // optional string comm = 1;
3478   if (cached_has_bits & 0x00000001u) {
3479     target = stream->WriteStringMaybeAliased(
3480         1, this->_internal_comm(), target);
3481   }
3482 
3483   // optional int32 pid = 2;
3484   if (cached_has_bits & 0x00000002u) {
3485     target = stream->EnsureSpace(target);
3486     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
3487   }
3488 
3489   // optional int32 prio = 3;
3490   if (cached_has_bits & 0x00000004u) {
3491     target = stream->EnsureSpace(target);
3492     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prio(), target);
3493   }
3494 
3495   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3496     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3497         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3498   }
3499   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedProcessFreeFtraceEvent)
3500   return target;
3501 }
3502 
ByteSizeLong() const3503 size_t SchedProcessFreeFtraceEvent::ByteSizeLong() const {
3504 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedProcessFreeFtraceEvent)
3505   size_t total_size = 0;
3506 
3507   ::uint32_t cached_has_bits = 0;
3508   // Prevent compiler warnings about cached_has_bits being unused
3509   (void) cached_has_bits;
3510 
3511   cached_has_bits = _impl_._has_bits_[0];
3512   if (cached_has_bits & 0x00000007u) {
3513     // optional string comm = 1;
3514     if (cached_has_bits & 0x00000001u) {
3515       total_size += 1 +
3516         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3517           this->_internal_comm());
3518     }
3519 
3520     // optional int32 pid = 2;
3521     if (cached_has_bits & 0x00000002u) {
3522       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
3523     }
3524 
3525     // optional int32 prio = 3;
3526     if (cached_has_bits & 0x00000004u) {
3527       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
3528     }
3529 
3530   }
3531   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3532     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3533   }
3534   int cached_size = ::_pbi::ToCachedSize(total_size);
3535   SetCachedSize(cached_size);
3536   return total_size;
3537 }
3538 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3539 void SchedProcessFreeFtraceEvent::CheckTypeAndMergeFrom(
3540     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3541   MergeFrom(*::_pbi::DownCast<const SchedProcessFreeFtraceEvent*>(
3542       &from));
3543 }
3544 
MergeFrom(const SchedProcessFreeFtraceEvent & from)3545 void SchedProcessFreeFtraceEvent::MergeFrom(const SchedProcessFreeFtraceEvent& from) {
3546   SchedProcessFreeFtraceEvent* const _this = this;
3547   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedProcessFreeFtraceEvent)
3548   GOOGLE_DCHECK_NE(&from, _this);
3549   ::uint32_t cached_has_bits = 0;
3550   (void) cached_has_bits;
3551 
3552   cached_has_bits = from._impl_._has_bits_[0];
3553   if (cached_has_bits & 0x00000007u) {
3554     if (cached_has_bits & 0x00000001u) {
3555       _this->_internal_set_comm(from._internal_comm());
3556     }
3557     if (cached_has_bits & 0x00000002u) {
3558       _this->_impl_.pid_ = from._impl_.pid_;
3559     }
3560     if (cached_has_bits & 0x00000004u) {
3561       _this->_impl_.prio_ = from._impl_.prio_;
3562     }
3563     _this->_impl_._has_bits_[0] |= cached_has_bits;
3564   }
3565   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3566 }
3567 
CopyFrom(const SchedProcessFreeFtraceEvent & from)3568 void SchedProcessFreeFtraceEvent::CopyFrom(const SchedProcessFreeFtraceEvent& from) {
3569 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedProcessFreeFtraceEvent)
3570   if (&from == this) return;
3571   Clear();
3572   MergeFrom(from);
3573 }
3574 
IsInitialized() const3575 bool SchedProcessFreeFtraceEvent::IsInitialized() const {
3576   return true;
3577 }
3578 
InternalSwap(SchedProcessFreeFtraceEvent * other)3579 void SchedProcessFreeFtraceEvent::InternalSwap(SchedProcessFreeFtraceEvent* other) {
3580   using std::swap;
3581   auto* lhs_arena = GetArenaForAllocation();
3582   auto* rhs_arena = other->GetArenaForAllocation();
3583   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3584   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3585   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3586       &_impl_.comm_, lhs_arena,
3587       &other->_impl_.comm_, rhs_arena
3588   );
3589   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3590       PROTOBUF_FIELD_OFFSET(SchedProcessFreeFtraceEvent, _impl_.prio_)
3591       + sizeof(SchedProcessFreeFtraceEvent::_impl_.prio_)  // NOLINT
3592       - PROTOBUF_FIELD_OFFSET(SchedProcessFreeFtraceEvent, _impl_.pid_)>(
3593           reinterpret_cast<char*>(&_impl_.pid_),
3594           reinterpret_cast<char*>(&other->_impl_.pid_));
3595 }
3596 
GetTypeName() const3597 std::string SchedProcessFreeFtraceEvent::GetTypeName() const {
3598   return "perfetto.protos.SchedProcessFreeFtraceEvent";
3599 }
3600 
3601 
3602 // ===================================================================
3603 
3604 class SchedProcessHangFtraceEvent::_Internal {
3605  public:
3606   using HasBits = decltype(std::declval<SchedProcessHangFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)3607   static void set_has_comm(HasBits* has_bits) {
3608     (*has_bits)[0] |= 1u;
3609   }
set_has_pid(HasBits * has_bits)3610   static void set_has_pid(HasBits* has_bits) {
3611     (*has_bits)[0] |= 2u;
3612   }
3613 };
3614 
SchedProcessHangFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3615 SchedProcessHangFtraceEvent::SchedProcessHangFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3616                          bool is_message_owned)
3617   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3618   SharedCtor(arena, is_message_owned);
3619   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedProcessHangFtraceEvent)
3620 }
SchedProcessHangFtraceEvent(const SchedProcessHangFtraceEvent & from)3621 SchedProcessHangFtraceEvent::SchedProcessHangFtraceEvent(const SchedProcessHangFtraceEvent& from)
3622   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3623   SchedProcessHangFtraceEvent* const _this = this; (void)_this;
3624   new (&_impl_) Impl_{
3625       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3626     , /*decltype(_impl_._cached_size_)*/{}
3627     , decltype(_impl_.comm_){}
3628     , decltype(_impl_.pid_){}};
3629 
3630   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3631   _impl_.comm_.InitDefault();
3632   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3633     _impl_.comm_.Set("", GetArenaForAllocation());
3634   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3635   if (from._internal_has_comm()) {
3636     _this->_impl_.comm_.Set(from._internal_comm(),
3637       _this->GetArenaForAllocation());
3638   }
3639   _this->_impl_.pid_ = from._impl_.pid_;
3640   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedProcessHangFtraceEvent)
3641 }
3642 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3643 inline void SchedProcessHangFtraceEvent::SharedCtor(
3644     ::_pb::Arena* arena, bool is_message_owned) {
3645   (void)arena;
3646   (void)is_message_owned;
3647   new (&_impl_) Impl_{
3648       decltype(_impl_._has_bits_){}
3649     , /*decltype(_impl_._cached_size_)*/{}
3650     , decltype(_impl_.comm_){}
3651     , decltype(_impl_.pid_){0}
3652   };
3653   _impl_.comm_.InitDefault();
3654   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3655     _impl_.comm_.Set("", GetArenaForAllocation());
3656   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3657 }
3658 
~SchedProcessHangFtraceEvent()3659 SchedProcessHangFtraceEvent::~SchedProcessHangFtraceEvent() {
3660   // @@protoc_insertion_point(destructor:perfetto.protos.SchedProcessHangFtraceEvent)
3661   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3662   (void)arena;
3663     return;
3664   }
3665   SharedDtor();
3666 }
3667 
SharedDtor()3668 inline void SchedProcessHangFtraceEvent::SharedDtor() {
3669   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3670   _impl_.comm_.Destroy();
3671 }
3672 
SetCachedSize(int size) const3673 void SchedProcessHangFtraceEvent::SetCachedSize(int size) const {
3674   _impl_._cached_size_.Set(size);
3675 }
3676 
Clear()3677 void SchedProcessHangFtraceEvent::Clear() {
3678 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedProcessHangFtraceEvent)
3679   ::uint32_t cached_has_bits = 0;
3680   // Prevent compiler warnings about cached_has_bits being unused
3681   (void) cached_has_bits;
3682 
3683   cached_has_bits = _impl_._has_bits_[0];
3684   if (cached_has_bits & 0x00000001u) {
3685     _impl_.comm_.ClearNonDefaultToEmpty();
3686   }
3687   _impl_.pid_ = 0;
3688   _impl_._has_bits_.Clear();
3689   _internal_metadata_.Clear<std::string>();
3690 }
3691 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3692 const char* SchedProcessHangFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3693 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3694   _Internal::HasBits has_bits{};
3695   while (!ctx->Done(&ptr)) {
3696     ::uint32_t tag;
3697     ptr = ::_pbi::ReadTag(ptr, &tag);
3698     switch (tag >> 3) {
3699       // optional string comm = 1;
3700       case 1:
3701         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3702           auto str = _internal_mutable_comm();
3703           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3704           CHK_(ptr);
3705         } else {
3706           goto handle_unusual;
3707         }
3708         continue;
3709       // optional int32 pid = 2;
3710       case 2:
3711         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3712           _Internal::set_has_pid(&has_bits);
3713           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3714           CHK_(ptr);
3715         } else {
3716           goto handle_unusual;
3717         }
3718         continue;
3719       default:
3720         goto handle_unusual;
3721     }  // switch
3722   handle_unusual:
3723     if ((tag == 0) || ((tag & 7) == 4)) {
3724       CHK_(ptr);
3725       ctx->SetLastTag(tag);
3726       goto message_done;
3727     }
3728     ptr = UnknownFieldParse(
3729         tag,
3730         _internal_metadata_.mutable_unknown_fields<std::string>(),
3731         ptr, ctx);
3732     CHK_(ptr != nullptr);
3733   }  // while
3734 message_done:
3735   _impl_._has_bits_.Or(has_bits);
3736   return ptr;
3737 failure:
3738   ptr = nullptr;
3739   goto message_done;
3740 #undef CHK_
3741 }
3742 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3743 ::uint8_t* SchedProcessHangFtraceEvent::_InternalSerialize(
3744     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3745   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedProcessHangFtraceEvent)
3746   ::uint32_t cached_has_bits = 0;
3747   (void) cached_has_bits;
3748 
3749   cached_has_bits = _impl_._has_bits_[0];
3750   // optional string comm = 1;
3751   if (cached_has_bits & 0x00000001u) {
3752     target = stream->WriteStringMaybeAliased(
3753         1, this->_internal_comm(), target);
3754   }
3755 
3756   // optional int32 pid = 2;
3757   if (cached_has_bits & 0x00000002u) {
3758     target = stream->EnsureSpace(target);
3759     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
3760   }
3761 
3762   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3763     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3764         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3765   }
3766   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedProcessHangFtraceEvent)
3767   return target;
3768 }
3769 
ByteSizeLong() const3770 size_t SchedProcessHangFtraceEvent::ByteSizeLong() const {
3771 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedProcessHangFtraceEvent)
3772   size_t total_size = 0;
3773 
3774   ::uint32_t cached_has_bits = 0;
3775   // Prevent compiler warnings about cached_has_bits being unused
3776   (void) cached_has_bits;
3777 
3778   cached_has_bits = _impl_._has_bits_[0];
3779   if (cached_has_bits & 0x00000003u) {
3780     // optional string comm = 1;
3781     if (cached_has_bits & 0x00000001u) {
3782       total_size += 1 +
3783         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3784           this->_internal_comm());
3785     }
3786 
3787     // optional int32 pid = 2;
3788     if (cached_has_bits & 0x00000002u) {
3789       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
3790     }
3791 
3792   }
3793   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3794     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3795   }
3796   int cached_size = ::_pbi::ToCachedSize(total_size);
3797   SetCachedSize(cached_size);
3798   return total_size;
3799 }
3800 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3801 void SchedProcessHangFtraceEvent::CheckTypeAndMergeFrom(
3802     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3803   MergeFrom(*::_pbi::DownCast<const SchedProcessHangFtraceEvent*>(
3804       &from));
3805 }
3806 
MergeFrom(const SchedProcessHangFtraceEvent & from)3807 void SchedProcessHangFtraceEvent::MergeFrom(const SchedProcessHangFtraceEvent& from) {
3808   SchedProcessHangFtraceEvent* const _this = this;
3809   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedProcessHangFtraceEvent)
3810   GOOGLE_DCHECK_NE(&from, _this);
3811   ::uint32_t cached_has_bits = 0;
3812   (void) cached_has_bits;
3813 
3814   cached_has_bits = from._impl_._has_bits_[0];
3815   if (cached_has_bits & 0x00000003u) {
3816     if (cached_has_bits & 0x00000001u) {
3817       _this->_internal_set_comm(from._internal_comm());
3818     }
3819     if (cached_has_bits & 0x00000002u) {
3820       _this->_impl_.pid_ = from._impl_.pid_;
3821     }
3822     _this->_impl_._has_bits_[0] |= cached_has_bits;
3823   }
3824   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3825 }
3826 
CopyFrom(const SchedProcessHangFtraceEvent & from)3827 void SchedProcessHangFtraceEvent::CopyFrom(const SchedProcessHangFtraceEvent& from) {
3828 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedProcessHangFtraceEvent)
3829   if (&from == this) return;
3830   Clear();
3831   MergeFrom(from);
3832 }
3833 
IsInitialized() const3834 bool SchedProcessHangFtraceEvent::IsInitialized() const {
3835   return true;
3836 }
3837 
InternalSwap(SchedProcessHangFtraceEvent * other)3838 void SchedProcessHangFtraceEvent::InternalSwap(SchedProcessHangFtraceEvent* other) {
3839   using std::swap;
3840   auto* lhs_arena = GetArenaForAllocation();
3841   auto* rhs_arena = other->GetArenaForAllocation();
3842   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3843   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3844   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3845       &_impl_.comm_, lhs_arena,
3846       &other->_impl_.comm_, rhs_arena
3847   );
3848   swap(_impl_.pid_, other->_impl_.pid_);
3849 }
3850 
GetTypeName() const3851 std::string SchedProcessHangFtraceEvent::GetTypeName() const {
3852   return "perfetto.protos.SchedProcessHangFtraceEvent";
3853 }
3854 
3855 
3856 // ===================================================================
3857 
3858 class SchedProcessWaitFtraceEvent::_Internal {
3859  public:
3860   using HasBits = decltype(std::declval<SchedProcessWaitFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)3861   static void set_has_comm(HasBits* has_bits) {
3862     (*has_bits)[0] |= 1u;
3863   }
set_has_pid(HasBits * has_bits)3864   static void set_has_pid(HasBits* has_bits) {
3865     (*has_bits)[0] |= 2u;
3866   }
set_has_prio(HasBits * has_bits)3867   static void set_has_prio(HasBits* has_bits) {
3868     (*has_bits)[0] |= 4u;
3869   }
3870 };
3871 
SchedProcessWaitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3872 SchedProcessWaitFtraceEvent::SchedProcessWaitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3873                          bool is_message_owned)
3874   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3875   SharedCtor(arena, is_message_owned);
3876   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedProcessWaitFtraceEvent)
3877 }
SchedProcessWaitFtraceEvent(const SchedProcessWaitFtraceEvent & from)3878 SchedProcessWaitFtraceEvent::SchedProcessWaitFtraceEvent(const SchedProcessWaitFtraceEvent& from)
3879   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3880   SchedProcessWaitFtraceEvent* const _this = this; (void)_this;
3881   new (&_impl_) Impl_{
3882       decltype(_impl_._has_bits_){from._impl_._has_bits_}
3883     , /*decltype(_impl_._cached_size_)*/{}
3884     , decltype(_impl_.comm_){}
3885     , decltype(_impl_.pid_){}
3886     , decltype(_impl_.prio_){}};
3887 
3888   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3889   _impl_.comm_.InitDefault();
3890   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3891     _impl_.comm_.Set("", GetArenaForAllocation());
3892   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3893   if (from._internal_has_comm()) {
3894     _this->_impl_.comm_.Set(from._internal_comm(),
3895       _this->GetArenaForAllocation());
3896   }
3897   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
3898     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
3899     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.prio_));
3900   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedProcessWaitFtraceEvent)
3901 }
3902 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3903 inline void SchedProcessWaitFtraceEvent::SharedCtor(
3904     ::_pb::Arena* arena, bool is_message_owned) {
3905   (void)arena;
3906   (void)is_message_owned;
3907   new (&_impl_) Impl_{
3908       decltype(_impl_._has_bits_){}
3909     , /*decltype(_impl_._cached_size_)*/{}
3910     , decltype(_impl_.comm_){}
3911     , decltype(_impl_.pid_){0}
3912     , decltype(_impl_.prio_){0}
3913   };
3914   _impl_.comm_.InitDefault();
3915   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3916     _impl_.comm_.Set("", GetArenaForAllocation());
3917   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3918 }
3919 
~SchedProcessWaitFtraceEvent()3920 SchedProcessWaitFtraceEvent::~SchedProcessWaitFtraceEvent() {
3921   // @@protoc_insertion_point(destructor:perfetto.protos.SchedProcessWaitFtraceEvent)
3922   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3923   (void)arena;
3924     return;
3925   }
3926   SharedDtor();
3927 }
3928 
SharedDtor()3929 inline void SchedProcessWaitFtraceEvent::SharedDtor() {
3930   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3931   _impl_.comm_.Destroy();
3932 }
3933 
SetCachedSize(int size) const3934 void SchedProcessWaitFtraceEvent::SetCachedSize(int size) const {
3935   _impl_._cached_size_.Set(size);
3936 }
3937 
Clear()3938 void SchedProcessWaitFtraceEvent::Clear() {
3939 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedProcessWaitFtraceEvent)
3940   ::uint32_t cached_has_bits = 0;
3941   // Prevent compiler warnings about cached_has_bits being unused
3942   (void) cached_has_bits;
3943 
3944   cached_has_bits = _impl_._has_bits_[0];
3945   if (cached_has_bits & 0x00000001u) {
3946     _impl_.comm_.ClearNonDefaultToEmpty();
3947   }
3948   if (cached_has_bits & 0x00000006u) {
3949     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
3950         reinterpret_cast<char*>(&_impl_.prio_) -
3951         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.prio_));
3952   }
3953   _impl_._has_bits_.Clear();
3954   _internal_metadata_.Clear<std::string>();
3955 }
3956 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3957 const char* SchedProcessWaitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3958 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3959   _Internal::HasBits has_bits{};
3960   while (!ctx->Done(&ptr)) {
3961     ::uint32_t tag;
3962     ptr = ::_pbi::ReadTag(ptr, &tag);
3963     switch (tag >> 3) {
3964       // optional string comm = 1;
3965       case 1:
3966         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
3967           auto str = _internal_mutable_comm();
3968           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3969           CHK_(ptr);
3970         } else {
3971           goto handle_unusual;
3972         }
3973         continue;
3974       // optional int32 pid = 2;
3975       case 2:
3976         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3977           _Internal::set_has_pid(&has_bits);
3978           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3979           CHK_(ptr);
3980         } else {
3981           goto handle_unusual;
3982         }
3983         continue;
3984       // optional int32 prio = 3;
3985       case 3:
3986         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3987           _Internal::set_has_prio(&has_bits);
3988           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3989           CHK_(ptr);
3990         } else {
3991           goto handle_unusual;
3992         }
3993         continue;
3994       default:
3995         goto handle_unusual;
3996     }  // switch
3997   handle_unusual:
3998     if ((tag == 0) || ((tag & 7) == 4)) {
3999       CHK_(ptr);
4000       ctx->SetLastTag(tag);
4001       goto message_done;
4002     }
4003     ptr = UnknownFieldParse(
4004         tag,
4005         _internal_metadata_.mutable_unknown_fields<std::string>(),
4006         ptr, ctx);
4007     CHK_(ptr != nullptr);
4008   }  // while
4009 message_done:
4010   _impl_._has_bits_.Or(has_bits);
4011   return ptr;
4012 failure:
4013   ptr = nullptr;
4014   goto message_done;
4015 #undef CHK_
4016 }
4017 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4018 ::uint8_t* SchedProcessWaitFtraceEvent::_InternalSerialize(
4019     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4020   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedProcessWaitFtraceEvent)
4021   ::uint32_t cached_has_bits = 0;
4022   (void) cached_has_bits;
4023 
4024   cached_has_bits = _impl_._has_bits_[0];
4025   // optional string comm = 1;
4026   if (cached_has_bits & 0x00000001u) {
4027     target = stream->WriteStringMaybeAliased(
4028         1, this->_internal_comm(), target);
4029   }
4030 
4031   // optional int32 pid = 2;
4032   if (cached_has_bits & 0x00000002u) {
4033     target = stream->EnsureSpace(target);
4034     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
4035   }
4036 
4037   // optional int32 prio = 3;
4038   if (cached_has_bits & 0x00000004u) {
4039     target = stream->EnsureSpace(target);
4040     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prio(), target);
4041   }
4042 
4043   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4044     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4045         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4046   }
4047   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedProcessWaitFtraceEvent)
4048   return target;
4049 }
4050 
ByteSizeLong() const4051 size_t SchedProcessWaitFtraceEvent::ByteSizeLong() const {
4052 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedProcessWaitFtraceEvent)
4053   size_t total_size = 0;
4054 
4055   ::uint32_t cached_has_bits = 0;
4056   // Prevent compiler warnings about cached_has_bits being unused
4057   (void) cached_has_bits;
4058 
4059   cached_has_bits = _impl_._has_bits_[0];
4060   if (cached_has_bits & 0x00000007u) {
4061     // optional string comm = 1;
4062     if (cached_has_bits & 0x00000001u) {
4063       total_size += 1 +
4064         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4065           this->_internal_comm());
4066     }
4067 
4068     // optional int32 pid = 2;
4069     if (cached_has_bits & 0x00000002u) {
4070       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
4071     }
4072 
4073     // optional int32 prio = 3;
4074     if (cached_has_bits & 0x00000004u) {
4075       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
4076     }
4077 
4078   }
4079   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4080     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4081   }
4082   int cached_size = ::_pbi::ToCachedSize(total_size);
4083   SetCachedSize(cached_size);
4084   return total_size;
4085 }
4086 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4087 void SchedProcessWaitFtraceEvent::CheckTypeAndMergeFrom(
4088     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4089   MergeFrom(*::_pbi::DownCast<const SchedProcessWaitFtraceEvent*>(
4090       &from));
4091 }
4092 
MergeFrom(const SchedProcessWaitFtraceEvent & from)4093 void SchedProcessWaitFtraceEvent::MergeFrom(const SchedProcessWaitFtraceEvent& from) {
4094   SchedProcessWaitFtraceEvent* const _this = this;
4095   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedProcessWaitFtraceEvent)
4096   GOOGLE_DCHECK_NE(&from, _this);
4097   ::uint32_t cached_has_bits = 0;
4098   (void) cached_has_bits;
4099 
4100   cached_has_bits = from._impl_._has_bits_[0];
4101   if (cached_has_bits & 0x00000007u) {
4102     if (cached_has_bits & 0x00000001u) {
4103       _this->_internal_set_comm(from._internal_comm());
4104     }
4105     if (cached_has_bits & 0x00000002u) {
4106       _this->_impl_.pid_ = from._impl_.pid_;
4107     }
4108     if (cached_has_bits & 0x00000004u) {
4109       _this->_impl_.prio_ = from._impl_.prio_;
4110     }
4111     _this->_impl_._has_bits_[0] |= cached_has_bits;
4112   }
4113   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4114 }
4115 
CopyFrom(const SchedProcessWaitFtraceEvent & from)4116 void SchedProcessWaitFtraceEvent::CopyFrom(const SchedProcessWaitFtraceEvent& from) {
4117 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedProcessWaitFtraceEvent)
4118   if (&from == this) return;
4119   Clear();
4120   MergeFrom(from);
4121 }
4122 
IsInitialized() const4123 bool SchedProcessWaitFtraceEvent::IsInitialized() const {
4124   return true;
4125 }
4126 
InternalSwap(SchedProcessWaitFtraceEvent * other)4127 void SchedProcessWaitFtraceEvent::InternalSwap(SchedProcessWaitFtraceEvent* other) {
4128   using std::swap;
4129   auto* lhs_arena = GetArenaForAllocation();
4130   auto* rhs_arena = other->GetArenaForAllocation();
4131   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4132   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4133   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4134       &_impl_.comm_, lhs_arena,
4135       &other->_impl_.comm_, rhs_arena
4136   );
4137   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4138       PROTOBUF_FIELD_OFFSET(SchedProcessWaitFtraceEvent, _impl_.prio_)
4139       + sizeof(SchedProcessWaitFtraceEvent::_impl_.prio_)  // NOLINT
4140       - PROTOBUF_FIELD_OFFSET(SchedProcessWaitFtraceEvent, _impl_.pid_)>(
4141           reinterpret_cast<char*>(&_impl_.pid_),
4142           reinterpret_cast<char*>(&other->_impl_.pid_));
4143 }
4144 
GetTypeName() const4145 std::string SchedProcessWaitFtraceEvent::GetTypeName() const {
4146   return "perfetto.protos.SchedProcessWaitFtraceEvent";
4147 }
4148 
4149 
4150 // ===================================================================
4151 
4152 class SchedPiSetprioFtraceEvent::_Internal {
4153  public:
4154   using HasBits = decltype(std::declval<SchedPiSetprioFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)4155   static void set_has_comm(HasBits* has_bits) {
4156     (*has_bits)[0] |= 1u;
4157   }
set_has_newprio(HasBits * has_bits)4158   static void set_has_newprio(HasBits* has_bits) {
4159     (*has_bits)[0] |= 2u;
4160   }
set_has_oldprio(HasBits * has_bits)4161   static void set_has_oldprio(HasBits* has_bits) {
4162     (*has_bits)[0] |= 4u;
4163   }
set_has_pid(HasBits * has_bits)4164   static void set_has_pid(HasBits* has_bits) {
4165     (*has_bits)[0] |= 8u;
4166   }
4167 };
4168 
SchedPiSetprioFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4169 SchedPiSetprioFtraceEvent::SchedPiSetprioFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4170                          bool is_message_owned)
4171   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4172   SharedCtor(arena, is_message_owned);
4173   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedPiSetprioFtraceEvent)
4174 }
SchedPiSetprioFtraceEvent(const SchedPiSetprioFtraceEvent & from)4175 SchedPiSetprioFtraceEvent::SchedPiSetprioFtraceEvent(const SchedPiSetprioFtraceEvent& from)
4176   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4177   SchedPiSetprioFtraceEvent* const _this = this; (void)_this;
4178   new (&_impl_) Impl_{
4179       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4180     , /*decltype(_impl_._cached_size_)*/{}
4181     , decltype(_impl_.comm_){}
4182     , decltype(_impl_.newprio_){}
4183     , decltype(_impl_.oldprio_){}
4184     , decltype(_impl_.pid_){}};
4185 
4186   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4187   _impl_.comm_.InitDefault();
4188   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4189     _impl_.comm_.Set("", GetArenaForAllocation());
4190   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4191   if (from._internal_has_comm()) {
4192     _this->_impl_.comm_.Set(from._internal_comm(),
4193       _this->GetArenaForAllocation());
4194   }
4195   ::memcpy(&_impl_.newprio_, &from._impl_.newprio_,
4196     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.pid_) -
4197     reinterpret_cast<char*>(&_impl_.newprio_)) + sizeof(_impl_.pid_));
4198   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedPiSetprioFtraceEvent)
4199 }
4200 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4201 inline void SchedPiSetprioFtraceEvent::SharedCtor(
4202     ::_pb::Arena* arena, bool is_message_owned) {
4203   (void)arena;
4204   (void)is_message_owned;
4205   new (&_impl_) Impl_{
4206       decltype(_impl_._has_bits_){}
4207     , /*decltype(_impl_._cached_size_)*/{}
4208     , decltype(_impl_.comm_){}
4209     , decltype(_impl_.newprio_){0}
4210     , decltype(_impl_.oldprio_){0}
4211     , decltype(_impl_.pid_){0}
4212   };
4213   _impl_.comm_.InitDefault();
4214   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4215     _impl_.comm_.Set("", GetArenaForAllocation());
4216   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4217 }
4218 
~SchedPiSetprioFtraceEvent()4219 SchedPiSetprioFtraceEvent::~SchedPiSetprioFtraceEvent() {
4220   // @@protoc_insertion_point(destructor:perfetto.protos.SchedPiSetprioFtraceEvent)
4221   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4222   (void)arena;
4223     return;
4224   }
4225   SharedDtor();
4226 }
4227 
SharedDtor()4228 inline void SchedPiSetprioFtraceEvent::SharedDtor() {
4229   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4230   _impl_.comm_.Destroy();
4231 }
4232 
SetCachedSize(int size) const4233 void SchedPiSetprioFtraceEvent::SetCachedSize(int size) const {
4234   _impl_._cached_size_.Set(size);
4235 }
4236 
Clear()4237 void SchedPiSetprioFtraceEvent::Clear() {
4238 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedPiSetprioFtraceEvent)
4239   ::uint32_t cached_has_bits = 0;
4240   // Prevent compiler warnings about cached_has_bits being unused
4241   (void) cached_has_bits;
4242 
4243   cached_has_bits = _impl_._has_bits_[0];
4244   if (cached_has_bits & 0x00000001u) {
4245     _impl_.comm_.ClearNonDefaultToEmpty();
4246   }
4247   if (cached_has_bits & 0x0000000eu) {
4248     ::memset(&_impl_.newprio_, 0, static_cast<size_t>(
4249         reinterpret_cast<char*>(&_impl_.pid_) -
4250         reinterpret_cast<char*>(&_impl_.newprio_)) + sizeof(_impl_.pid_));
4251   }
4252   _impl_._has_bits_.Clear();
4253   _internal_metadata_.Clear<std::string>();
4254 }
4255 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4256 const char* SchedPiSetprioFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4257 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4258   _Internal::HasBits has_bits{};
4259   while (!ctx->Done(&ptr)) {
4260     ::uint32_t tag;
4261     ptr = ::_pbi::ReadTag(ptr, &tag);
4262     switch (tag >> 3) {
4263       // optional string comm = 1;
4264       case 1:
4265         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
4266           auto str = _internal_mutable_comm();
4267           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4268           CHK_(ptr);
4269         } else {
4270           goto handle_unusual;
4271         }
4272         continue;
4273       // optional int32 newprio = 2;
4274       case 2:
4275         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4276           _Internal::set_has_newprio(&has_bits);
4277           _impl_.newprio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4278           CHK_(ptr);
4279         } else {
4280           goto handle_unusual;
4281         }
4282         continue;
4283       // optional int32 oldprio = 3;
4284       case 3:
4285         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4286           _Internal::set_has_oldprio(&has_bits);
4287           _impl_.oldprio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4288           CHK_(ptr);
4289         } else {
4290           goto handle_unusual;
4291         }
4292         continue;
4293       // optional int32 pid = 4;
4294       case 4:
4295         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4296           _Internal::set_has_pid(&has_bits);
4297           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4298           CHK_(ptr);
4299         } else {
4300           goto handle_unusual;
4301         }
4302         continue;
4303       default:
4304         goto handle_unusual;
4305     }  // switch
4306   handle_unusual:
4307     if ((tag == 0) || ((tag & 7) == 4)) {
4308       CHK_(ptr);
4309       ctx->SetLastTag(tag);
4310       goto message_done;
4311     }
4312     ptr = UnknownFieldParse(
4313         tag,
4314         _internal_metadata_.mutable_unknown_fields<std::string>(),
4315         ptr, ctx);
4316     CHK_(ptr != nullptr);
4317   }  // while
4318 message_done:
4319   _impl_._has_bits_.Or(has_bits);
4320   return ptr;
4321 failure:
4322   ptr = nullptr;
4323   goto message_done;
4324 #undef CHK_
4325 }
4326 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4327 ::uint8_t* SchedPiSetprioFtraceEvent::_InternalSerialize(
4328     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4329   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedPiSetprioFtraceEvent)
4330   ::uint32_t cached_has_bits = 0;
4331   (void) cached_has_bits;
4332 
4333   cached_has_bits = _impl_._has_bits_[0];
4334   // optional string comm = 1;
4335   if (cached_has_bits & 0x00000001u) {
4336     target = stream->WriteStringMaybeAliased(
4337         1, this->_internal_comm(), target);
4338   }
4339 
4340   // optional int32 newprio = 2;
4341   if (cached_has_bits & 0x00000002u) {
4342     target = stream->EnsureSpace(target);
4343     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_newprio(), target);
4344   }
4345 
4346   // optional int32 oldprio = 3;
4347   if (cached_has_bits & 0x00000004u) {
4348     target = stream->EnsureSpace(target);
4349     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_oldprio(), target);
4350   }
4351 
4352   // optional int32 pid = 4;
4353   if (cached_has_bits & 0x00000008u) {
4354     target = stream->EnsureSpace(target);
4355     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_pid(), target);
4356   }
4357 
4358   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4359     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4360         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4361   }
4362   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedPiSetprioFtraceEvent)
4363   return target;
4364 }
4365 
ByteSizeLong() const4366 size_t SchedPiSetprioFtraceEvent::ByteSizeLong() const {
4367 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedPiSetprioFtraceEvent)
4368   size_t total_size = 0;
4369 
4370   ::uint32_t cached_has_bits = 0;
4371   // Prevent compiler warnings about cached_has_bits being unused
4372   (void) cached_has_bits;
4373 
4374   cached_has_bits = _impl_._has_bits_[0];
4375   if (cached_has_bits & 0x0000000fu) {
4376     // optional string comm = 1;
4377     if (cached_has_bits & 0x00000001u) {
4378       total_size += 1 +
4379         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
4380           this->_internal_comm());
4381     }
4382 
4383     // optional int32 newprio = 2;
4384     if (cached_has_bits & 0x00000002u) {
4385       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_newprio());
4386     }
4387 
4388     // optional int32 oldprio = 3;
4389     if (cached_has_bits & 0x00000004u) {
4390       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_oldprio());
4391     }
4392 
4393     // optional int32 pid = 4;
4394     if (cached_has_bits & 0x00000008u) {
4395       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
4396     }
4397 
4398   }
4399   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4400     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4401   }
4402   int cached_size = ::_pbi::ToCachedSize(total_size);
4403   SetCachedSize(cached_size);
4404   return total_size;
4405 }
4406 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4407 void SchedPiSetprioFtraceEvent::CheckTypeAndMergeFrom(
4408     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4409   MergeFrom(*::_pbi::DownCast<const SchedPiSetprioFtraceEvent*>(
4410       &from));
4411 }
4412 
MergeFrom(const SchedPiSetprioFtraceEvent & from)4413 void SchedPiSetprioFtraceEvent::MergeFrom(const SchedPiSetprioFtraceEvent& from) {
4414   SchedPiSetprioFtraceEvent* const _this = this;
4415   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedPiSetprioFtraceEvent)
4416   GOOGLE_DCHECK_NE(&from, _this);
4417   ::uint32_t cached_has_bits = 0;
4418   (void) cached_has_bits;
4419 
4420   cached_has_bits = from._impl_._has_bits_[0];
4421   if (cached_has_bits & 0x0000000fu) {
4422     if (cached_has_bits & 0x00000001u) {
4423       _this->_internal_set_comm(from._internal_comm());
4424     }
4425     if (cached_has_bits & 0x00000002u) {
4426       _this->_impl_.newprio_ = from._impl_.newprio_;
4427     }
4428     if (cached_has_bits & 0x00000004u) {
4429       _this->_impl_.oldprio_ = from._impl_.oldprio_;
4430     }
4431     if (cached_has_bits & 0x00000008u) {
4432       _this->_impl_.pid_ = from._impl_.pid_;
4433     }
4434     _this->_impl_._has_bits_[0] |= cached_has_bits;
4435   }
4436   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4437 }
4438 
CopyFrom(const SchedPiSetprioFtraceEvent & from)4439 void SchedPiSetprioFtraceEvent::CopyFrom(const SchedPiSetprioFtraceEvent& from) {
4440 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedPiSetprioFtraceEvent)
4441   if (&from == this) return;
4442   Clear();
4443   MergeFrom(from);
4444 }
4445 
IsInitialized() const4446 bool SchedPiSetprioFtraceEvent::IsInitialized() const {
4447   return true;
4448 }
4449 
InternalSwap(SchedPiSetprioFtraceEvent * other)4450 void SchedPiSetprioFtraceEvent::InternalSwap(SchedPiSetprioFtraceEvent* other) {
4451   using std::swap;
4452   auto* lhs_arena = GetArenaForAllocation();
4453   auto* rhs_arena = other->GetArenaForAllocation();
4454   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4455   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4456   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
4457       &_impl_.comm_, lhs_arena,
4458       &other->_impl_.comm_, rhs_arena
4459   );
4460   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4461       PROTOBUF_FIELD_OFFSET(SchedPiSetprioFtraceEvent, _impl_.pid_)
4462       + sizeof(SchedPiSetprioFtraceEvent::_impl_.pid_)  // NOLINT
4463       - PROTOBUF_FIELD_OFFSET(SchedPiSetprioFtraceEvent, _impl_.newprio_)>(
4464           reinterpret_cast<char*>(&_impl_.newprio_),
4465           reinterpret_cast<char*>(&other->_impl_.newprio_));
4466 }
4467 
GetTypeName() const4468 std::string SchedPiSetprioFtraceEvent::GetTypeName() const {
4469   return "perfetto.protos.SchedPiSetprioFtraceEvent";
4470 }
4471 
4472 
4473 // ===================================================================
4474 
4475 class SchedCpuUtilCfsFtraceEvent::_Internal {
4476  public:
4477   using HasBits = decltype(std::declval<SchedCpuUtilCfsFtraceEvent>()._impl_._has_bits_);
set_has_active(HasBits * has_bits)4478   static void set_has_active(HasBits* has_bits) {
4479     (*has_bits)[0] |= 2u;
4480   }
set_has_capacity(HasBits * has_bits)4481   static void set_has_capacity(HasBits* has_bits) {
4482     (*has_bits)[0] |= 1u;
4483   }
set_has_capacity_orig(HasBits * has_bits)4484   static void set_has_capacity_orig(HasBits* has_bits) {
4485     (*has_bits)[0] |= 8u;
4486   }
set_has_cpu(HasBits * has_bits)4487   static void set_has_cpu(HasBits* has_bits) {
4488     (*has_bits)[0] |= 4u;
4489   }
set_has_cpu_importance(HasBits * has_bits)4490   static void set_has_cpu_importance(HasBits* has_bits) {
4491     (*has_bits)[0] |= 16u;
4492   }
set_has_cpu_util(HasBits * has_bits)4493   static void set_has_cpu_util(HasBits* has_bits) {
4494     (*has_bits)[0] |= 32u;
4495   }
set_has_exit_lat(HasBits * has_bits)4496   static void set_has_exit_lat(HasBits* has_bits) {
4497     (*has_bits)[0] |= 128u;
4498   }
set_has_group_capacity(HasBits * has_bits)4499   static void set_has_group_capacity(HasBits* has_bits) {
4500     (*has_bits)[0] |= 64u;
4501   }
set_has_grp_overutilized(HasBits * has_bits)4502   static void set_has_grp_overutilized(HasBits* has_bits) {
4503     (*has_bits)[0] |= 256u;
4504   }
set_has_idle_cpu(HasBits * has_bits)4505   static void set_has_idle_cpu(HasBits* has_bits) {
4506     (*has_bits)[0] |= 512u;
4507   }
set_has_nr_running(HasBits * has_bits)4508   static void set_has_nr_running(HasBits* has_bits) {
4509     (*has_bits)[0] |= 1024u;
4510   }
set_has_spare_cap(HasBits * has_bits)4511   static void set_has_spare_cap(HasBits* has_bits) {
4512     (*has_bits)[0] |= 2048u;
4513   }
set_has_task_fits(HasBits * has_bits)4514   static void set_has_task_fits(HasBits* has_bits) {
4515     (*has_bits)[0] |= 16384u;
4516   }
set_has_wake_group_util(HasBits * has_bits)4517   static void set_has_wake_group_util(HasBits* has_bits) {
4518     (*has_bits)[0] |= 4096u;
4519   }
set_has_wake_util(HasBits * has_bits)4520   static void set_has_wake_util(HasBits* has_bits) {
4521     (*has_bits)[0] |= 8192u;
4522   }
4523 };
4524 
SchedCpuUtilCfsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4525 SchedCpuUtilCfsFtraceEvent::SchedCpuUtilCfsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4526                          bool is_message_owned)
4527   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4528   SharedCtor(arena, is_message_owned);
4529   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4530 }
SchedCpuUtilCfsFtraceEvent(const SchedCpuUtilCfsFtraceEvent & from)4531 SchedCpuUtilCfsFtraceEvent::SchedCpuUtilCfsFtraceEvent(const SchedCpuUtilCfsFtraceEvent& from)
4532   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4533   SchedCpuUtilCfsFtraceEvent* const _this = this; (void)_this;
4534   new (&_impl_) Impl_{
4535       decltype(_impl_._has_bits_){from._impl_._has_bits_}
4536     , /*decltype(_impl_._cached_size_)*/{}
4537     , decltype(_impl_.capacity_){}
4538     , decltype(_impl_.active_){}
4539     , decltype(_impl_.cpu_){}
4540     , decltype(_impl_.capacity_orig_){}
4541     , decltype(_impl_.cpu_importance_){}
4542     , decltype(_impl_.cpu_util_){}
4543     , decltype(_impl_.group_capacity_){}
4544     , decltype(_impl_.exit_lat_){}
4545     , decltype(_impl_.grp_overutilized_){}
4546     , decltype(_impl_.idle_cpu_){}
4547     , decltype(_impl_.nr_running_){}
4548     , decltype(_impl_.spare_cap_){}
4549     , decltype(_impl_.wake_group_util_){}
4550     , decltype(_impl_.wake_util_){}
4551     , decltype(_impl_.task_fits_){}};
4552 
4553   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4554   ::memcpy(&_impl_.capacity_, &from._impl_.capacity_,
4555     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.task_fits_) -
4556     reinterpret_cast<char*>(&_impl_.capacity_)) + sizeof(_impl_.task_fits_));
4557   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4558 }
4559 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4560 inline void SchedCpuUtilCfsFtraceEvent::SharedCtor(
4561     ::_pb::Arena* arena, bool is_message_owned) {
4562   (void)arena;
4563   (void)is_message_owned;
4564   new (&_impl_) Impl_{
4565       decltype(_impl_._has_bits_){}
4566     , /*decltype(_impl_._cached_size_)*/{}
4567     , decltype(_impl_.capacity_){::uint64_t{0u}}
4568     , decltype(_impl_.active_){0}
4569     , decltype(_impl_.cpu_){0u}
4570     , decltype(_impl_.capacity_orig_){::uint64_t{0u}}
4571     , decltype(_impl_.cpu_importance_){::uint64_t{0u}}
4572     , decltype(_impl_.cpu_util_){::uint64_t{0u}}
4573     , decltype(_impl_.group_capacity_){::uint64_t{0u}}
4574     , decltype(_impl_.exit_lat_){0u}
4575     , decltype(_impl_.grp_overutilized_){0u}
4576     , decltype(_impl_.idle_cpu_){0u}
4577     , decltype(_impl_.nr_running_){0u}
4578     , decltype(_impl_.spare_cap_){::int64_t{0}}
4579     , decltype(_impl_.wake_group_util_){::uint64_t{0u}}
4580     , decltype(_impl_.wake_util_){::uint64_t{0u}}
4581     , decltype(_impl_.task_fits_){0u}
4582   };
4583 }
4584 
~SchedCpuUtilCfsFtraceEvent()4585 SchedCpuUtilCfsFtraceEvent::~SchedCpuUtilCfsFtraceEvent() {
4586   // @@protoc_insertion_point(destructor:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4587   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4588   (void)arena;
4589     return;
4590   }
4591   SharedDtor();
4592 }
4593 
SharedDtor()4594 inline void SchedCpuUtilCfsFtraceEvent::SharedDtor() {
4595   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4596 }
4597 
SetCachedSize(int size) const4598 void SchedCpuUtilCfsFtraceEvent::SetCachedSize(int size) const {
4599   _impl_._cached_size_.Set(size);
4600 }
4601 
Clear()4602 void SchedCpuUtilCfsFtraceEvent::Clear() {
4603 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4604   ::uint32_t cached_has_bits = 0;
4605   // Prevent compiler warnings about cached_has_bits being unused
4606   (void) cached_has_bits;
4607 
4608   cached_has_bits = _impl_._has_bits_[0];
4609   if (cached_has_bits & 0x000000ffu) {
4610     ::memset(&_impl_.capacity_, 0, static_cast<size_t>(
4611         reinterpret_cast<char*>(&_impl_.exit_lat_) -
4612         reinterpret_cast<char*>(&_impl_.capacity_)) + sizeof(_impl_.exit_lat_));
4613   }
4614   if (cached_has_bits & 0x00007f00u) {
4615     ::memset(&_impl_.grp_overutilized_, 0, static_cast<size_t>(
4616         reinterpret_cast<char*>(&_impl_.task_fits_) -
4617         reinterpret_cast<char*>(&_impl_.grp_overutilized_)) + sizeof(_impl_.task_fits_));
4618   }
4619   _impl_._has_bits_.Clear();
4620   _internal_metadata_.Clear<std::string>();
4621 }
4622 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4623 const char* SchedCpuUtilCfsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4624 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4625   _Internal::HasBits has_bits{};
4626   while (!ctx->Done(&ptr)) {
4627     ::uint32_t tag;
4628     ptr = ::_pbi::ReadTag(ptr, &tag);
4629     switch (tag >> 3) {
4630       // optional int32 active = 1;
4631       case 1:
4632         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4633           _Internal::set_has_active(&has_bits);
4634           _impl_.active_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4635           CHK_(ptr);
4636         } else {
4637           goto handle_unusual;
4638         }
4639         continue;
4640       // optional uint64 capacity = 2;
4641       case 2:
4642         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4643           _Internal::set_has_capacity(&has_bits);
4644           _impl_.capacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4645           CHK_(ptr);
4646         } else {
4647           goto handle_unusual;
4648         }
4649         continue;
4650       // optional uint64 capacity_orig = 3;
4651       case 3:
4652         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4653           _Internal::set_has_capacity_orig(&has_bits);
4654           _impl_.capacity_orig_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4655           CHK_(ptr);
4656         } else {
4657           goto handle_unusual;
4658         }
4659         continue;
4660       // optional uint32 cpu = 4;
4661       case 4:
4662         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4663           _Internal::set_has_cpu(&has_bits);
4664           _impl_.cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4665           CHK_(ptr);
4666         } else {
4667           goto handle_unusual;
4668         }
4669         continue;
4670       // optional uint64 cpu_importance = 5;
4671       case 5:
4672         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
4673           _Internal::set_has_cpu_importance(&has_bits);
4674           _impl_.cpu_importance_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4675           CHK_(ptr);
4676         } else {
4677           goto handle_unusual;
4678         }
4679         continue;
4680       // optional uint64 cpu_util = 6;
4681       case 6:
4682         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
4683           _Internal::set_has_cpu_util(&has_bits);
4684           _impl_.cpu_util_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4685           CHK_(ptr);
4686         } else {
4687           goto handle_unusual;
4688         }
4689         continue;
4690       // optional uint32 exit_lat = 7;
4691       case 7:
4692         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
4693           _Internal::set_has_exit_lat(&has_bits);
4694           _impl_.exit_lat_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4695           CHK_(ptr);
4696         } else {
4697           goto handle_unusual;
4698         }
4699         continue;
4700       // optional uint64 group_capacity = 8;
4701       case 8:
4702         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
4703           _Internal::set_has_group_capacity(&has_bits);
4704           _impl_.group_capacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4705           CHK_(ptr);
4706         } else {
4707           goto handle_unusual;
4708         }
4709         continue;
4710       // optional uint32 grp_overutilized = 9;
4711       case 9:
4712         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
4713           _Internal::set_has_grp_overutilized(&has_bits);
4714           _impl_.grp_overutilized_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4715           CHK_(ptr);
4716         } else {
4717           goto handle_unusual;
4718         }
4719         continue;
4720       // optional uint32 idle_cpu = 10;
4721       case 10:
4722         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
4723           _Internal::set_has_idle_cpu(&has_bits);
4724           _impl_.idle_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4725           CHK_(ptr);
4726         } else {
4727           goto handle_unusual;
4728         }
4729         continue;
4730       // optional uint32 nr_running = 11;
4731       case 11:
4732         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
4733           _Internal::set_has_nr_running(&has_bits);
4734           _impl_.nr_running_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4735           CHK_(ptr);
4736         } else {
4737           goto handle_unusual;
4738         }
4739         continue;
4740       // optional int64 spare_cap = 12;
4741       case 12:
4742         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
4743           _Internal::set_has_spare_cap(&has_bits);
4744           _impl_.spare_cap_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4745           CHK_(ptr);
4746         } else {
4747           goto handle_unusual;
4748         }
4749         continue;
4750       // optional uint32 task_fits = 13;
4751       case 13:
4752         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
4753           _Internal::set_has_task_fits(&has_bits);
4754           _impl_.task_fits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4755           CHK_(ptr);
4756         } else {
4757           goto handle_unusual;
4758         }
4759         continue;
4760       // optional uint64 wake_group_util = 14;
4761       case 14:
4762         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
4763           _Internal::set_has_wake_group_util(&has_bits);
4764           _impl_.wake_group_util_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4765           CHK_(ptr);
4766         } else {
4767           goto handle_unusual;
4768         }
4769         continue;
4770       // optional uint64 wake_util = 15;
4771       case 15:
4772         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
4773           _Internal::set_has_wake_util(&has_bits);
4774           _impl_.wake_util_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
4775           CHK_(ptr);
4776         } else {
4777           goto handle_unusual;
4778         }
4779         continue;
4780       default:
4781         goto handle_unusual;
4782     }  // switch
4783   handle_unusual:
4784     if ((tag == 0) || ((tag & 7) == 4)) {
4785       CHK_(ptr);
4786       ctx->SetLastTag(tag);
4787       goto message_done;
4788     }
4789     ptr = UnknownFieldParse(
4790         tag,
4791         _internal_metadata_.mutable_unknown_fields<std::string>(),
4792         ptr, ctx);
4793     CHK_(ptr != nullptr);
4794   }  // while
4795 message_done:
4796   _impl_._has_bits_.Or(has_bits);
4797   return ptr;
4798 failure:
4799   ptr = nullptr;
4800   goto message_done;
4801 #undef CHK_
4802 }
4803 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4804 ::uint8_t* SchedCpuUtilCfsFtraceEvent::_InternalSerialize(
4805     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4806   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4807   ::uint32_t cached_has_bits = 0;
4808   (void) cached_has_bits;
4809 
4810   cached_has_bits = _impl_._has_bits_[0];
4811   // optional int32 active = 1;
4812   if (cached_has_bits & 0x00000002u) {
4813     target = stream->EnsureSpace(target);
4814     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_active(), target);
4815   }
4816 
4817   // optional uint64 capacity = 2;
4818   if (cached_has_bits & 0x00000001u) {
4819     target = stream->EnsureSpace(target);
4820     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_capacity(), target);
4821   }
4822 
4823   // optional uint64 capacity_orig = 3;
4824   if (cached_has_bits & 0x00000008u) {
4825     target = stream->EnsureSpace(target);
4826     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_capacity_orig(), target);
4827   }
4828 
4829   // optional uint32 cpu = 4;
4830   if (cached_has_bits & 0x00000004u) {
4831     target = stream->EnsureSpace(target);
4832     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_cpu(), target);
4833   }
4834 
4835   // optional uint64 cpu_importance = 5;
4836   if (cached_has_bits & 0x00000010u) {
4837     target = stream->EnsureSpace(target);
4838     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_cpu_importance(), target);
4839   }
4840 
4841   // optional uint64 cpu_util = 6;
4842   if (cached_has_bits & 0x00000020u) {
4843     target = stream->EnsureSpace(target);
4844     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_cpu_util(), target);
4845   }
4846 
4847   // optional uint32 exit_lat = 7;
4848   if (cached_has_bits & 0x00000080u) {
4849     target = stream->EnsureSpace(target);
4850     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_exit_lat(), target);
4851   }
4852 
4853   // optional uint64 group_capacity = 8;
4854   if (cached_has_bits & 0x00000040u) {
4855     target = stream->EnsureSpace(target);
4856     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_group_capacity(), target);
4857   }
4858 
4859   // optional uint32 grp_overutilized = 9;
4860   if (cached_has_bits & 0x00000100u) {
4861     target = stream->EnsureSpace(target);
4862     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_grp_overutilized(), target);
4863   }
4864 
4865   // optional uint32 idle_cpu = 10;
4866   if (cached_has_bits & 0x00000200u) {
4867     target = stream->EnsureSpace(target);
4868     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_idle_cpu(), target);
4869   }
4870 
4871   // optional uint32 nr_running = 11;
4872   if (cached_has_bits & 0x00000400u) {
4873     target = stream->EnsureSpace(target);
4874     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_nr_running(), target);
4875   }
4876 
4877   // optional int64 spare_cap = 12;
4878   if (cached_has_bits & 0x00000800u) {
4879     target = stream->EnsureSpace(target);
4880     target = ::_pbi::WireFormatLite::WriteInt64ToArray(12, this->_internal_spare_cap(), target);
4881   }
4882 
4883   // optional uint32 task_fits = 13;
4884   if (cached_has_bits & 0x00004000u) {
4885     target = stream->EnsureSpace(target);
4886     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(13, this->_internal_task_fits(), target);
4887   }
4888 
4889   // optional uint64 wake_group_util = 14;
4890   if (cached_has_bits & 0x00001000u) {
4891     target = stream->EnsureSpace(target);
4892     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(14, this->_internal_wake_group_util(), target);
4893   }
4894 
4895   // optional uint64 wake_util = 15;
4896   if (cached_has_bits & 0x00002000u) {
4897     target = stream->EnsureSpace(target);
4898     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(15, this->_internal_wake_util(), target);
4899   }
4900 
4901   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4902     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4903         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4904   }
4905   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4906   return target;
4907 }
4908 
ByteSizeLong() const4909 size_t SchedCpuUtilCfsFtraceEvent::ByteSizeLong() const {
4910 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
4911   size_t total_size = 0;
4912 
4913   ::uint32_t cached_has_bits = 0;
4914   // Prevent compiler warnings about cached_has_bits being unused
4915   (void) cached_has_bits;
4916 
4917   cached_has_bits = _impl_._has_bits_[0];
4918   if (cached_has_bits & 0x000000ffu) {
4919     // optional uint64 capacity = 2;
4920     if (cached_has_bits & 0x00000001u) {
4921       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_capacity());
4922     }
4923 
4924     // optional int32 active = 1;
4925     if (cached_has_bits & 0x00000002u) {
4926       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_active());
4927     }
4928 
4929     // optional uint32 cpu = 4;
4930     if (cached_has_bits & 0x00000004u) {
4931       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cpu());
4932     }
4933 
4934     // optional uint64 capacity_orig = 3;
4935     if (cached_has_bits & 0x00000008u) {
4936       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_capacity_orig());
4937     }
4938 
4939     // optional uint64 cpu_importance = 5;
4940     if (cached_has_bits & 0x00000010u) {
4941       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cpu_importance());
4942     }
4943 
4944     // optional uint64 cpu_util = 6;
4945     if (cached_has_bits & 0x00000020u) {
4946       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cpu_util());
4947     }
4948 
4949     // optional uint64 group_capacity = 8;
4950     if (cached_has_bits & 0x00000040u) {
4951       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_group_capacity());
4952     }
4953 
4954     // optional uint32 exit_lat = 7;
4955     if (cached_has_bits & 0x00000080u) {
4956       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_exit_lat());
4957     }
4958 
4959   }
4960   if (cached_has_bits & 0x00007f00u) {
4961     // optional uint32 grp_overutilized = 9;
4962     if (cached_has_bits & 0x00000100u) {
4963       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_grp_overutilized());
4964     }
4965 
4966     // optional uint32 idle_cpu = 10;
4967     if (cached_has_bits & 0x00000200u) {
4968       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_idle_cpu());
4969     }
4970 
4971     // optional uint32 nr_running = 11;
4972     if (cached_has_bits & 0x00000400u) {
4973       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nr_running());
4974     }
4975 
4976     // optional int64 spare_cap = 12;
4977     if (cached_has_bits & 0x00000800u) {
4978       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_spare_cap());
4979     }
4980 
4981     // optional uint64 wake_group_util = 14;
4982     if (cached_has_bits & 0x00001000u) {
4983       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_wake_group_util());
4984     }
4985 
4986     // optional uint64 wake_util = 15;
4987     if (cached_has_bits & 0x00002000u) {
4988       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_wake_util());
4989     }
4990 
4991     // optional uint32 task_fits = 13;
4992     if (cached_has_bits & 0x00004000u) {
4993       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_task_fits());
4994     }
4995 
4996   }
4997   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4998     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4999   }
5000   int cached_size = ::_pbi::ToCachedSize(total_size);
5001   SetCachedSize(cached_size);
5002   return total_size;
5003 }
5004 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5005 void SchedCpuUtilCfsFtraceEvent::CheckTypeAndMergeFrom(
5006     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5007   MergeFrom(*::_pbi::DownCast<const SchedCpuUtilCfsFtraceEvent*>(
5008       &from));
5009 }
5010 
MergeFrom(const SchedCpuUtilCfsFtraceEvent & from)5011 void SchedCpuUtilCfsFtraceEvent::MergeFrom(const SchedCpuUtilCfsFtraceEvent& from) {
5012   SchedCpuUtilCfsFtraceEvent* const _this = this;
5013   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
5014   GOOGLE_DCHECK_NE(&from, _this);
5015   ::uint32_t cached_has_bits = 0;
5016   (void) cached_has_bits;
5017 
5018   cached_has_bits = from._impl_._has_bits_[0];
5019   if (cached_has_bits & 0x000000ffu) {
5020     if (cached_has_bits & 0x00000001u) {
5021       _this->_impl_.capacity_ = from._impl_.capacity_;
5022     }
5023     if (cached_has_bits & 0x00000002u) {
5024       _this->_impl_.active_ = from._impl_.active_;
5025     }
5026     if (cached_has_bits & 0x00000004u) {
5027       _this->_impl_.cpu_ = from._impl_.cpu_;
5028     }
5029     if (cached_has_bits & 0x00000008u) {
5030       _this->_impl_.capacity_orig_ = from._impl_.capacity_orig_;
5031     }
5032     if (cached_has_bits & 0x00000010u) {
5033       _this->_impl_.cpu_importance_ = from._impl_.cpu_importance_;
5034     }
5035     if (cached_has_bits & 0x00000020u) {
5036       _this->_impl_.cpu_util_ = from._impl_.cpu_util_;
5037     }
5038     if (cached_has_bits & 0x00000040u) {
5039       _this->_impl_.group_capacity_ = from._impl_.group_capacity_;
5040     }
5041     if (cached_has_bits & 0x00000080u) {
5042       _this->_impl_.exit_lat_ = from._impl_.exit_lat_;
5043     }
5044     _this->_impl_._has_bits_[0] |= cached_has_bits;
5045   }
5046   if (cached_has_bits & 0x00007f00u) {
5047     if (cached_has_bits & 0x00000100u) {
5048       _this->_impl_.grp_overutilized_ = from._impl_.grp_overutilized_;
5049     }
5050     if (cached_has_bits & 0x00000200u) {
5051       _this->_impl_.idle_cpu_ = from._impl_.idle_cpu_;
5052     }
5053     if (cached_has_bits & 0x00000400u) {
5054       _this->_impl_.nr_running_ = from._impl_.nr_running_;
5055     }
5056     if (cached_has_bits & 0x00000800u) {
5057       _this->_impl_.spare_cap_ = from._impl_.spare_cap_;
5058     }
5059     if (cached_has_bits & 0x00001000u) {
5060       _this->_impl_.wake_group_util_ = from._impl_.wake_group_util_;
5061     }
5062     if (cached_has_bits & 0x00002000u) {
5063       _this->_impl_.wake_util_ = from._impl_.wake_util_;
5064     }
5065     if (cached_has_bits & 0x00004000u) {
5066       _this->_impl_.task_fits_ = from._impl_.task_fits_;
5067     }
5068     _this->_impl_._has_bits_[0] |= cached_has_bits;
5069   }
5070   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5071 }
5072 
CopyFrom(const SchedCpuUtilCfsFtraceEvent & from)5073 void SchedCpuUtilCfsFtraceEvent::CopyFrom(const SchedCpuUtilCfsFtraceEvent& from) {
5074 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedCpuUtilCfsFtraceEvent)
5075   if (&from == this) return;
5076   Clear();
5077   MergeFrom(from);
5078 }
5079 
IsInitialized() const5080 bool SchedCpuUtilCfsFtraceEvent::IsInitialized() const {
5081   return true;
5082 }
5083 
InternalSwap(SchedCpuUtilCfsFtraceEvent * other)5084 void SchedCpuUtilCfsFtraceEvent::InternalSwap(SchedCpuUtilCfsFtraceEvent* other) {
5085   using std::swap;
5086   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5087   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5088   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5089       PROTOBUF_FIELD_OFFSET(SchedCpuUtilCfsFtraceEvent, _impl_.task_fits_)
5090       + sizeof(SchedCpuUtilCfsFtraceEvent::_impl_.task_fits_)  // NOLINT
5091       - PROTOBUF_FIELD_OFFSET(SchedCpuUtilCfsFtraceEvent, _impl_.capacity_)>(
5092           reinterpret_cast<char*>(&_impl_.capacity_),
5093           reinterpret_cast<char*>(&other->_impl_.capacity_));
5094 }
5095 
GetTypeName() const5096 std::string SchedCpuUtilCfsFtraceEvent::GetTypeName() const {
5097   return "perfetto.protos.SchedCpuUtilCfsFtraceEvent";
5098 }
5099 
5100 
5101 // ===================================================================
5102 
5103 class SchedMigrateTaskFtraceEvent::_Internal {
5104  public:
5105   using HasBits = decltype(std::declval<SchedMigrateTaskFtraceEvent>()._impl_._has_bits_);
set_has_comm(HasBits * has_bits)5106   static void set_has_comm(HasBits* has_bits) {
5107     (*has_bits)[0] |= 1u;
5108   }
set_has_pid(HasBits * has_bits)5109   static void set_has_pid(HasBits* has_bits) {
5110     (*has_bits)[0] |= 2u;
5111   }
set_has_prio(HasBits * has_bits)5112   static void set_has_prio(HasBits* has_bits) {
5113     (*has_bits)[0] |= 4u;
5114   }
set_has_orig_cpu(HasBits * has_bits)5115   static void set_has_orig_cpu(HasBits* has_bits) {
5116     (*has_bits)[0] |= 8u;
5117   }
set_has_dest_cpu(HasBits * has_bits)5118   static void set_has_dest_cpu(HasBits* has_bits) {
5119     (*has_bits)[0] |= 16u;
5120   }
set_has_running(HasBits * has_bits)5121   static void set_has_running(HasBits* has_bits) {
5122     (*has_bits)[0] |= 32u;
5123   }
set_has_load(HasBits * has_bits)5124   static void set_has_load(HasBits* has_bits) {
5125     (*has_bits)[0] |= 64u;
5126   }
5127 };
5128 
SchedMigrateTaskFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5129 SchedMigrateTaskFtraceEvent::SchedMigrateTaskFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5130                          bool is_message_owned)
5131   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5132   SharedCtor(arena, is_message_owned);
5133   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedMigrateTaskFtraceEvent)
5134 }
SchedMigrateTaskFtraceEvent(const SchedMigrateTaskFtraceEvent & from)5135 SchedMigrateTaskFtraceEvent::SchedMigrateTaskFtraceEvent(const SchedMigrateTaskFtraceEvent& from)
5136   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5137   SchedMigrateTaskFtraceEvent* const _this = this; (void)_this;
5138   new (&_impl_) Impl_{
5139       decltype(_impl_._has_bits_){from._impl_._has_bits_}
5140     , /*decltype(_impl_._cached_size_)*/{}
5141     , decltype(_impl_.comm_){}
5142     , decltype(_impl_.pid_){}
5143     , decltype(_impl_.prio_){}
5144     , decltype(_impl_.orig_cpu_){}
5145     , decltype(_impl_.dest_cpu_){}
5146     , decltype(_impl_.running_){}
5147     , decltype(_impl_.load_){}};
5148 
5149   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5150   _impl_.comm_.InitDefault();
5151   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5152     _impl_.comm_.Set("", GetArenaForAllocation());
5153   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5154   if (from._internal_has_comm()) {
5155     _this->_impl_.comm_.Set(from._internal_comm(),
5156       _this->GetArenaForAllocation());
5157   }
5158   ::memcpy(&_impl_.pid_, &from._impl_.pid_,
5159     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.load_) -
5160     reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.load_));
5161   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedMigrateTaskFtraceEvent)
5162 }
5163 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5164 inline void SchedMigrateTaskFtraceEvent::SharedCtor(
5165     ::_pb::Arena* arena, bool is_message_owned) {
5166   (void)arena;
5167   (void)is_message_owned;
5168   new (&_impl_) Impl_{
5169       decltype(_impl_._has_bits_){}
5170     , /*decltype(_impl_._cached_size_)*/{}
5171     , decltype(_impl_.comm_){}
5172     , decltype(_impl_.pid_){0}
5173     , decltype(_impl_.prio_){0}
5174     , decltype(_impl_.orig_cpu_){0}
5175     , decltype(_impl_.dest_cpu_){0}
5176     , decltype(_impl_.running_){0}
5177     , decltype(_impl_.load_){0u}
5178   };
5179   _impl_.comm_.InitDefault();
5180   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
5181     _impl_.comm_.Set("", GetArenaForAllocation());
5182   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
5183 }
5184 
~SchedMigrateTaskFtraceEvent()5185 SchedMigrateTaskFtraceEvent::~SchedMigrateTaskFtraceEvent() {
5186   // @@protoc_insertion_point(destructor:perfetto.protos.SchedMigrateTaskFtraceEvent)
5187   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5188   (void)arena;
5189     return;
5190   }
5191   SharedDtor();
5192 }
5193 
SharedDtor()5194 inline void SchedMigrateTaskFtraceEvent::SharedDtor() {
5195   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5196   _impl_.comm_.Destroy();
5197 }
5198 
SetCachedSize(int size) const5199 void SchedMigrateTaskFtraceEvent::SetCachedSize(int size) const {
5200   _impl_._cached_size_.Set(size);
5201 }
5202 
Clear()5203 void SchedMigrateTaskFtraceEvent::Clear() {
5204 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedMigrateTaskFtraceEvent)
5205   ::uint32_t cached_has_bits = 0;
5206   // Prevent compiler warnings about cached_has_bits being unused
5207   (void) cached_has_bits;
5208 
5209   cached_has_bits = _impl_._has_bits_[0];
5210   if (cached_has_bits & 0x00000001u) {
5211     _impl_.comm_.ClearNonDefaultToEmpty();
5212   }
5213   if (cached_has_bits & 0x0000007eu) {
5214     ::memset(&_impl_.pid_, 0, static_cast<size_t>(
5215         reinterpret_cast<char*>(&_impl_.load_) -
5216         reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.load_));
5217   }
5218   _impl_._has_bits_.Clear();
5219   _internal_metadata_.Clear<std::string>();
5220 }
5221 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5222 const char* SchedMigrateTaskFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5223 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5224   _Internal::HasBits has_bits{};
5225   while (!ctx->Done(&ptr)) {
5226     ::uint32_t tag;
5227     ptr = ::_pbi::ReadTag(ptr, &tag);
5228     switch (tag >> 3) {
5229       // optional string comm = 1;
5230       case 1:
5231         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
5232           auto str = _internal_mutable_comm();
5233           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
5234           CHK_(ptr);
5235         } else {
5236           goto handle_unusual;
5237         }
5238         continue;
5239       // optional int32 pid = 2;
5240       case 2:
5241         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5242           _Internal::set_has_pid(&has_bits);
5243           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5244           CHK_(ptr);
5245         } else {
5246           goto handle_unusual;
5247         }
5248         continue;
5249       // optional int32 prio = 3;
5250       case 3:
5251         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5252           _Internal::set_has_prio(&has_bits);
5253           _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5254           CHK_(ptr);
5255         } else {
5256           goto handle_unusual;
5257         }
5258         continue;
5259       // optional int32 orig_cpu = 4;
5260       case 4:
5261         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5262           _Internal::set_has_orig_cpu(&has_bits);
5263           _impl_.orig_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5264           CHK_(ptr);
5265         } else {
5266           goto handle_unusual;
5267         }
5268         continue;
5269       // optional int32 dest_cpu = 5;
5270       case 5:
5271         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
5272           _Internal::set_has_dest_cpu(&has_bits);
5273           _impl_.dest_cpu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5274           CHK_(ptr);
5275         } else {
5276           goto handle_unusual;
5277         }
5278         continue;
5279       // optional int32 running = 6;
5280       case 6:
5281         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
5282           _Internal::set_has_running(&has_bits);
5283           _impl_.running_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5284           CHK_(ptr);
5285         } else {
5286           goto handle_unusual;
5287         }
5288         continue;
5289       // optional uint32 load = 7;
5290       case 7:
5291         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
5292           _Internal::set_has_load(&has_bits);
5293           _impl_.load_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5294           CHK_(ptr);
5295         } else {
5296           goto handle_unusual;
5297         }
5298         continue;
5299       default:
5300         goto handle_unusual;
5301     }  // switch
5302   handle_unusual:
5303     if ((tag == 0) || ((tag & 7) == 4)) {
5304       CHK_(ptr);
5305       ctx->SetLastTag(tag);
5306       goto message_done;
5307     }
5308     ptr = UnknownFieldParse(
5309         tag,
5310         _internal_metadata_.mutable_unknown_fields<std::string>(),
5311         ptr, ctx);
5312     CHK_(ptr != nullptr);
5313   }  // while
5314 message_done:
5315   _impl_._has_bits_.Or(has_bits);
5316   return ptr;
5317 failure:
5318   ptr = nullptr;
5319   goto message_done;
5320 #undef CHK_
5321 }
5322 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5323 ::uint8_t* SchedMigrateTaskFtraceEvent::_InternalSerialize(
5324     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5325   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedMigrateTaskFtraceEvent)
5326   ::uint32_t cached_has_bits = 0;
5327   (void) cached_has_bits;
5328 
5329   cached_has_bits = _impl_._has_bits_[0];
5330   // optional string comm = 1;
5331   if (cached_has_bits & 0x00000001u) {
5332     target = stream->WriteStringMaybeAliased(
5333         1, this->_internal_comm(), target);
5334   }
5335 
5336   // optional int32 pid = 2;
5337   if (cached_has_bits & 0x00000002u) {
5338     target = stream->EnsureSpace(target);
5339     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
5340   }
5341 
5342   // optional int32 prio = 3;
5343   if (cached_has_bits & 0x00000004u) {
5344     target = stream->EnsureSpace(target);
5345     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_prio(), target);
5346   }
5347 
5348   // optional int32 orig_cpu = 4;
5349   if (cached_has_bits & 0x00000008u) {
5350     target = stream->EnsureSpace(target);
5351     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_orig_cpu(), target);
5352   }
5353 
5354   // optional int32 dest_cpu = 5;
5355   if (cached_has_bits & 0x00000010u) {
5356     target = stream->EnsureSpace(target);
5357     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_dest_cpu(), target);
5358   }
5359 
5360   // optional int32 running = 6;
5361   if (cached_has_bits & 0x00000020u) {
5362     target = stream->EnsureSpace(target);
5363     target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_running(), target);
5364   }
5365 
5366   // optional uint32 load = 7;
5367   if (cached_has_bits & 0x00000040u) {
5368     target = stream->EnsureSpace(target);
5369     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_load(), target);
5370   }
5371 
5372   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5373     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5374         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5375   }
5376   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedMigrateTaskFtraceEvent)
5377   return target;
5378 }
5379 
ByteSizeLong() const5380 size_t SchedMigrateTaskFtraceEvent::ByteSizeLong() const {
5381 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedMigrateTaskFtraceEvent)
5382   size_t total_size = 0;
5383 
5384   ::uint32_t cached_has_bits = 0;
5385   // Prevent compiler warnings about cached_has_bits being unused
5386   (void) cached_has_bits;
5387 
5388   cached_has_bits = _impl_._has_bits_[0];
5389   if (cached_has_bits & 0x0000007fu) {
5390     // optional string comm = 1;
5391     if (cached_has_bits & 0x00000001u) {
5392       total_size += 1 +
5393         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5394           this->_internal_comm());
5395     }
5396 
5397     // optional int32 pid = 2;
5398     if (cached_has_bits & 0x00000002u) {
5399       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
5400     }
5401 
5402     // optional int32 prio = 3;
5403     if (cached_has_bits & 0x00000004u) {
5404       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
5405     }
5406 
5407     // optional int32 orig_cpu = 4;
5408     if (cached_has_bits & 0x00000008u) {
5409       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_orig_cpu());
5410     }
5411 
5412     // optional int32 dest_cpu = 5;
5413     if (cached_has_bits & 0x00000010u) {
5414       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dest_cpu());
5415     }
5416 
5417     // optional int32 running = 6;
5418     if (cached_has_bits & 0x00000020u) {
5419       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_running());
5420     }
5421 
5422     // optional uint32 load = 7;
5423     if (cached_has_bits & 0x00000040u) {
5424       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_load());
5425     }
5426 
5427   }
5428   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5429     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5430   }
5431   int cached_size = ::_pbi::ToCachedSize(total_size);
5432   SetCachedSize(cached_size);
5433   return total_size;
5434 }
5435 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5436 void SchedMigrateTaskFtraceEvent::CheckTypeAndMergeFrom(
5437     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5438   MergeFrom(*::_pbi::DownCast<const SchedMigrateTaskFtraceEvent*>(
5439       &from));
5440 }
5441 
MergeFrom(const SchedMigrateTaskFtraceEvent & from)5442 void SchedMigrateTaskFtraceEvent::MergeFrom(const SchedMigrateTaskFtraceEvent& from) {
5443   SchedMigrateTaskFtraceEvent* const _this = this;
5444   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedMigrateTaskFtraceEvent)
5445   GOOGLE_DCHECK_NE(&from, _this);
5446   ::uint32_t cached_has_bits = 0;
5447   (void) cached_has_bits;
5448 
5449   cached_has_bits = from._impl_._has_bits_[0];
5450   if (cached_has_bits & 0x0000007fu) {
5451     if (cached_has_bits & 0x00000001u) {
5452       _this->_internal_set_comm(from._internal_comm());
5453     }
5454     if (cached_has_bits & 0x00000002u) {
5455       _this->_impl_.pid_ = from._impl_.pid_;
5456     }
5457     if (cached_has_bits & 0x00000004u) {
5458       _this->_impl_.prio_ = from._impl_.prio_;
5459     }
5460     if (cached_has_bits & 0x00000008u) {
5461       _this->_impl_.orig_cpu_ = from._impl_.orig_cpu_;
5462     }
5463     if (cached_has_bits & 0x00000010u) {
5464       _this->_impl_.dest_cpu_ = from._impl_.dest_cpu_;
5465     }
5466     if (cached_has_bits & 0x00000020u) {
5467       _this->_impl_.running_ = from._impl_.running_;
5468     }
5469     if (cached_has_bits & 0x00000040u) {
5470       _this->_impl_.load_ = from._impl_.load_;
5471     }
5472     _this->_impl_._has_bits_[0] |= cached_has_bits;
5473   }
5474   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5475 }
5476 
CopyFrom(const SchedMigrateTaskFtraceEvent & from)5477 void SchedMigrateTaskFtraceEvent::CopyFrom(const SchedMigrateTaskFtraceEvent& from) {
5478 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedMigrateTaskFtraceEvent)
5479   if (&from == this) return;
5480   Clear();
5481   MergeFrom(from);
5482 }
5483 
IsInitialized() const5484 bool SchedMigrateTaskFtraceEvent::IsInitialized() const {
5485   return true;
5486 }
5487 
InternalSwap(SchedMigrateTaskFtraceEvent * other)5488 void SchedMigrateTaskFtraceEvent::InternalSwap(SchedMigrateTaskFtraceEvent* other) {
5489   using std::swap;
5490   auto* lhs_arena = GetArenaForAllocation();
5491   auto* rhs_arena = other->GetArenaForAllocation();
5492   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5493   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5494   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5495       &_impl_.comm_, lhs_arena,
5496       &other->_impl_.comm_, rhs_arena
5497   );
5498   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5499       PROTOBUF_FIELD_OFFSET(SchedMigrateTaskFtraceEvent, _impl_.load_)
5500       + sizeof(SchedMigrateTaskFtraceEvent::_impl_.load_)  // NOLINT
5501       - PROTOBUF_FIELD_OFFSET(SchedMigrateTaskFtraceEvent, _impl_.pid_)>(
5502           reinterpret_cast<char*>(&_impl_.pid_),
5503           reinterpret_cast<char*>(&other->_impl_.pid_));
5504 }
5505 
GetTypeName() const5506 std::string SchedMigrateTaskFtraceEvent::GetTypeName() const {
5507   return "perfetto.protos.SchedMigrateTaskFtraceEvent";
5508 }
5509 
5510 
5511 // ===================================================================
5512 
5513 class SchedWakeupTaskAttrFtraceEvent::_Internal {
5514  public:
5515   using HasBits = decltype(std::declval<SchedWakeupTaskAttrFtraceEvent>()._impl_._has_bits_);
set_has_pid(HasBits * has_bits)5516   static void set_has_pid(HasBits* has_bits) {
5517     (*has_bits)[0] |= 16u;
5518   }
set_has_cpu_affinity(HasBits * has_bits)5519   static void set_has_cpu_affinity(HasBits* has_bits) {
5520     (*has_bits)[0] |= 1u;
5521   }
set_has_task_util(HasBits * has_bits)5522   static void set_has_task_util(HasBits* has_bits) {
5523     (*has_bits)[0] |= 2u;
5524   }
set_has_uclamp_min(HasBits * has_bits)5525   static void set_has_uclamp_min(HasBits* has_bits) {
5526     (*has_bits)[0] |= 4u;
5527   }
set_has_vruntime(HasBits * has_bits)5528   static void set_has_vruntime(HasBits* has_bits) {
5529     (*has_bits)[0] |= 8u;
5530   }
5531 };
5532 
SchedWakeupTaskAttrFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5533 SchedWakeupTaskAttrFtraceEvent::SchedWakeupTaskAttrFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5534                          bool is_message_owned)
5535   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5536   SharedCtor(arena, is_message_owned);
5537   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5538 }
SchedWakeupTaskAttrFtraceEvent(const SchedWakeupTaskAttrFtraceEvent & from)5539 SchedWakeupTaskAttrFtraceEvent::SchedWakeupTaskAttrFtraceEvent(const SchedWakeupTaskAttrFtraceEvent& from)
5540   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5541   SchedWakeupTaskAttrFtraceEvent* const _this = this; (void)_this;
5542   new (&_impl_) Impl_{
5543       decltype(_impl_._has_bits_){from._impl_._has_bits_}
5544     , /*decltype(_impl_._cached_size_)*/{}
5545     , decltype(_impl_.cpu_affinity_){}
5546     , decltype(_impl_.task_util_){}
5547     , decltype(_impl_.uclamp_min_){}
5548     , decltype(_impl_.vruntime_){}
5549     , decltype(_impl_.pid_){}};
5550 
5551   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5552   ::memcpy(&_impl_.cpu_affinity_, &from._impl_.cpu_affinity_,
5553     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.pid_) -
5554     reinterpret_cast<char*>(&_impl_.cpu_affinity_)) + sizeof(_impl_.pid_));
5555   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5556 }
5557 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5558 inline void SchedWakeupTaskAttrFtraceEvent::SharedCtor(
5559     ::_pb::Arena* arena, bool is_message_owned) {
5560   (void)arena;
5561   (void)is_message_owned;
5562   new (&_impl_) Impl_{
5563       decltype(_impl_._has_bits_){}
5564     , /*decltype(_impl_._cached_size_)*/{}
5565     , decltype(_impl_.cpu_affinity_){::uint64_t{0u}}
5566     , decltype(_impl_.task_util_){::uint64_t{0u}}
5567     , decltype(_impl_.uclamp_min_){::uint64_t{0u}}
5568     , decltype(_impl_.vruntime_){::uint64_t{0u}}
5569     , decltype(_impl_.pid_){0}
5570   };
5571 }
5572 
~SchedWakeupTaskAttrFtraceEvent()5573 SchedWakeupTaskAttrFtraceEvent::~SchedWakeupTaskAttrFtraceEvent() {
5574   // @@protoc_insertion_point(destructor:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5575   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5576   (void)arena;
5577     return;
5578   }
5579   SharedDtor();
5580 }
5581 
SharedDtor()5582 inline void SchedWakeupTaskAttrFtraceEvent::SharedDtor() {
5583   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5584 }
5585 
SetCachedSize(int size) const5586 void SchedWakeupTaskAttrFtraceEvent::SetCachedSize(int size) const {
5587   _impl_._cached_size_.Set(size);
5588 }
5589 
Clear()5590 void SchedWakeupTaskAttrFtraceEvent::Clear() {
5591 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5592   ::uint32_t cached_has_bits = 0;
5593   // Prevent compiler warnings about cached_has_bits being unused
5594   (void) cached_has_bits;
5595 
5596   cached_has_bits = _impl_._has_bits_[0];
5597   if (cached_has_bits & 0x0000001fu) {
5598     ::memset(&_impl_.cpu_affinity_, 0, static_cast<size_t>(
5599         reinterpret_cast<char*>(&_impl_.pid_) -
5600         reinterpret_cast<char*>(&_impl_.cpu_affinity_)) + sizeof(_impl_.pid_));
5601   }
5602   _impl_._has_bits_.Clear();
5603   _internal_metadata_.Clear<std::string>();
5604 }
5605 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5606 const char* SchedWakeupTaskAttrFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5607 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5608   _Internal::HasBits has_bits{};
5609   while (!ctx->Done(&ptr)) {
5610     ::uint32_t tag;
5611     ptr = ::_pbi::ReadTag(ptr, &tag);
5612     switch (tag >> 3) {
5613       // optional int32 pid = 1;
5614       case 1:
5615         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5616           _Internal::set_has_pid(&has_bits);
5617           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5618           CHK_(ptr);
5619         } else {
5620           goto handle_unusual;
5621         }
5622         continue;
5623       // optional uint64 cpu_affinity = 2;
5624       case 2:
5625         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5626           _Internal::set_has_cpu_affinity(&has_bits);
5627           _impl_.cpu_affinity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5628           CHK_(ptr);
5629         } else {
5630           goto handle_unusual;
5631         }
5632         continue;
5633       // optional uint64 task_util = 3;
5634       case 3:
5635         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5636           _Internal::set_has_task_util(&has_bits);
5637           _impl_.task_util_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5638           CHK_(ptr);
5639         } else {
5640           goto handle_unusual;
5641         }
5642         continue;
5643       // optional uint64 uclamp_min = 4;
5644       case 4:
5645         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5646           _Internal::set_has_uclamp_min(&has_bits);
5647           _impl_.uclamp_min_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5648           CHK_(ptr);
5649         } else {
5650           goto handle_unusual;
5651         }
5652         continue;
5653       // optional uint64 vruntime = 5;
5654       case 5:
5655         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
5656           _Internal::set_has_vruntime(&has_bits);
5657           _impl_.vruntime_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
5658           CHK_(ptr);
5659         } else {
5660           goto handle_unusual;
5661         }
5662         continue;
5663       default:
5664         goto handle_unusual;
5665     }  // switch
5666   handle_unusual:
5667     if ((tag == 0) || ((tag & 7) == 4)) {
5668       CHK_(ptr);
5669       ctx->SetLastTag(tag);
5670       goto message_done;
5671     }
5672     ptr = UnknownFieldParse(
5673         tag,
5674         _internal_metadata_.mutable_unknown_fields<std::string>(),
5675         ptr, ctx);
5676     CHK_(ptr != nullptr);
5677   }  // while
5678 message_done:
5679   _impl_._has_bits_.Or(has_bits);
5680   return ptr;
5681 failure:
5682   ptr = nullptr;
5683   goto message_done;
5684 #undef CHK_
5685 }
5686 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5687 ::uint8_t* SchedWakeupTaskAttrFtraceEvent::_InternalSerialize(
5688     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5689   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5690   ::uint32_t cached_has_bits = 0;
5691   (void) cached_has_bits;
5692 
5693   cached_has_bits = _impl_._has_bits_[0];
5694   // optional int32 pid = 1;
5695   if (cached_has_bits & 0x00000010u) {
5696     target = stream->EnsureSpace(target);
5697     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_pid(), target);
5698   }
5699 
5700   // optional uint64 cpu_affinity = 2;
5701   if (cached_has_bits & 0x00000001u) {
5702     target = stream->EnsureSpace(target);
5703     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_cpu_affinity(), target);
5704   }
5705 
5706   // optional uint64 task_util = 3;
5707   if (cached_has_bits & 0x00000002u) {
5708     target = stream->EnsureSpace(target);
5709     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_task_util(), target);
5710   }
5711 
5712   // optional uint64 uclamp_min = 4;
5713   if (cached_has_bits & 0x00000004u) {
5714     target = stream->EnsureSpace(target);
5715     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_uclamp_min(), target);
5716   }
5717 
5718   // optional uint64 vruntime = 5;
5719   if (cached_has_bits & 0x00000008u) {
5720     target = stream->EnsureSpace(target);
5721     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_vruntime(), target);
5722   }
5723 
5724   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5725     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5726         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5727   }
5728   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5729   return target;
5730 }
5731 
ByteSizeLong() const5732 size_t SchedWakeupTaskAttrFtraceEvent::ByteSizeLong() const {
5733 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5734   size_t total_size = 0;
5735 
5736   ::uint32_t cached_has_bits = 0;
5737   // Prevent compiler warnings about cached_has_bits being unused
5738   (void) cached_has_bits;
5739 
5740   cached_has_bits = _impl_._has_bits_[0];
5741   if (cached_has_bits & 0x0000001fu) {
5742     // optional uint64 cpu_affinity = 2;
5743     if (cached_has_bits & 0x00000001u) {
5744       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cpu_affinity());
5745     }
5746 
5747     // optional uint64 task_util = 3;
5748     if (cached_has_bits & 0x00000002u) {
5749       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_task_util());
5750     }
5751 
5752     // optional uint64 uclamp_min = 4;
5753     if (cached_has_bits & 0x00000004u) {
5754       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_uclamp_min());
5755     }
5756 
5757     // optional uint64 vruntime = 5;
5758     if (cached_has_bits & 0x00000008u) {
5759       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_vruntime());
5760     }
5761 
5762     // optional int32 pid = 1;
5763     if (cached_has_bits & 0x00000010u) {
5764       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
5765     }
5766 
5767   }
5768   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5769     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5770   }
5771   int cached_size = ::_pbi::ToCachedSize(total_size);
5772   SetCachedSize(cached_size);
5773   return total_size;
5774 }
5775 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5776 void SchedWakeupTaskAttrFtraceEvent::CheckTypeAndMergeFrom(
5777     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5778   MergeFrom(*::_pbi::DownCast<const SchedWakeupTaskAttrFtraceEvent*>(
5779       &from));
5780 }
5781 
MergeFrom(const SchedWakeupTaskAttrFtraceEvent & from)5782 void SchedWakeupTaskAttrFtraceEvent::MergeFrom(const SchedWakeupTaskAttrFtraceEvent& from) {
5783   SchedWakeupTaskAttrFtraceEvent* const _this = this;
5784   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5785   GOOGLE_DCHECK_NE(&from, _this);
5786   ::uint32_t cached_has_bits = 0;
5787   (void) cached_has_bits;
5788 
5789   cached_has_bits = from._impl_._has_bits_[0];
5790   if (cached_has_bits & 0x0000001fu) {
5791     if (cached_has_bits & 0x00000001u) {
5792       _this->_impl_.cpu_affinity_ = from._impl_.cpu_affinity_;
5793     }
5794     if (cached_has_bits & 0x00000002u) {
5795       _this->_impl_.task_util_ = from._impl_.task_util_;
5796     }
5797     if (cached_has_bits & 0x00000004u) {
5798       _this->_impl_.uclamp_min_ = from._impl_.uclamp_min_;
5799     }
5800     if (cached_has_bits & 0x00000008u) {
5801       _this->_impl_.vruntime_ = from._impl_.vruntime_;
5802     }
5803     if (cached_has_bits & 0x00000010u) {
5804       _this->_impl_.pid_ = from._impl_.pid_;
5805     }
5806     _this->_impl_._has_bits_[0] |= cached_has_bits;
5807   }
5808   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5809 }
5810 
CopyFrom(const SchedWakeupTaskAttrFtraceEvent & from)5811 void SchedWakeupTaskAttrFtraceEvent::CopyFrom(const SchedWakeupTaskAttrFtraceEvent& from) {
5812 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedWakeupTaskAttrFtraceEvent)
5813   if (&from == this) return;
5814   Clear();
5815   MergeFrom(from);
5816 }
5817 
IsInitialized() const5818 bool SchedWakeupTaskAttrFtraceEvent::IsInitialized() const {
5819   return true;
5820 }
5821 
InternalSwap(SchedWakeupTaskAttrFtraceEvent * other)5822 void SchedWakeupTaskAttrFtraceEvent::InternalSwap(SchedWakeupTaskAttrFtraceEvent* other) {
5823   using std::swap;
5824   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5825   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5826   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5827       PROTOBUF_FIELD_OFFSET(SchedWakeupTaskAttrFtraceEvent, _impl_.pid_)
5828       + sizeof(SchedWakeupTaskAttrFtraceEvent::_impl_.pid_)  // NOLINT
5829       - PROTOBUF_FIELD_OFFSET(SchedWakeupTaskAttrFtraceEvent, _impl_.cpu_affinity_)>(
5830           reinterpret_cast<char*>(&_impl_.cpu_affinity_),
5831           reinterpret_cast<char*>(&other->_impl_.cpu_affinity_));
5832 }
5833 
GetTypeName() const5834 std::string SchedWakeupTaskAttrFtraceEvent::GetTypeName() const {
5835   return "perfetto.protos.SchedWakeupTaskAttrFtraceEvent";
5836 }
5837 
5838 
5839 // @@protoc_insertion_point(namespace_scope)
5840 }  // namespace protos
5841 }  // namespace perfetto
5842 PROTOBUF_NAMESPACE_OPEN
5843 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedSwitchFtraceEvent*
CreateMaybeMessage(Arena * arena)5844 Arena::CreateMaybeMessage< ::perfetto::protos::SchedSwitchFtraceEvent >(Arena* arena) {
5845   return Arena::CreateMessageInternal< ::perfetto::protos::SchedSwitchFtraceEvent >(arena);
5846 }
5847 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedWakeupFtraceEvent*
CreateMaybeMessage(Arena * arena)5848 Arena::CreateMaybeMessage< ::perfetto::protos::SchedWakeupFtraceEvent >(Arena* arena) {
5849   return Arena::CreateMessageInternal< ::perfetto::protos::SchedWakeupFtraceEvent >(arena);
5850 }
5851 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedBlockedReasonFtraceEvent*
CreateMaybeMessage(Arena * arena)5852 Arena::CreateMaybeMessage< ::perfetto::protos::SchedBlockedReasonFtraceEvent >(Arena* arena) {
5853   return Arena::CreateMessageInternal< ::perfetto::protos::SchedBlockedReasonFtraceEvent >(arena);
5854 }
5855 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedCpuHotplugFtraceEvent*
CreateMaybeMessage(Arena * arena)5856 Arena::CreateMaybeMessage< ::perfetto::protos::SchedCpuHotplugFtraceEvent >(Arena* arena) {
5857   return Arena::CreateMessageInternal< ::perfetto::protos::SchedCpuHotplugFtraceEvent >(arena);
5858 }
5859 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedWakingFtraceEvent*
CreateMaybeMessage(Arena * arena)5860 Arena::CreateMaybeMessage< ::perfetto::protos::SchedWakingFtraceEvent >(Arena* arena) {
5861   return Arena::CreateMessageInternal< ::perfetto::protos::SchedWakingFtraceEvent >(arena);
5862 }
5863 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedWakeupNewFtraceEvent*
CreateMaybeMessage(Arena * arena)5864 Arena::CreateMaybeMessage< ::perfetto::protos::SchedWakeupNewFtraceEvent >(Arena* arena) {
5865   return Arena::CreateMessageInternal< ::perfetto::protos::SchedWakeupNewFtraceEvent >(arena);
5866 }
5867 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedProcessExecFtraceEvent*
CreateMaybeMessage(Arena * arena)5868 Arena::CreateMaybeMessage< ::perfetto::protos::SchedProcessExecFtraceEvent >(Arena* arena) {
5869   return Arena::CreateMessageInternal< ::perfetto::protos::SchedProcessExecFtraceEvent >(arena);
5870 }
5871 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedProcessExitFtraceEvent*
CreateMaybeMessage(Arena * arena)5872 Arena::CreateMaybeMessage< ::perfetto::protos::SchedProcessExitFtraceEvent >(Arena* arena) {
5873   return Arena::CreateMessageInternal< ::perfetto::protos::SchedProcessExitFtraceEvent >(arena);
5874 }
5875 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedProcessForkFtraceEvent*
CreateMaybeMessage(Arena * arena)5876 Arena::CreateMaybeMessage< ::perfetto::protos::SchedProcessForkFtraceEvent >(Arena* arena) {
5877   return Arena::CreateMessageInternal< ::perfetto::protos::SchedProcessForkFtraceEvent >(arena);
5878 }
5879 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedProcessFreeFtraceEvent*
CreateMaybeMessage(Arena * arena)5880 Arena::CreateMaybeMessage< ::perfetto::protos::SchedProcessFreeFtraceEvent >(Arena* arena) {
5881   return Arena::CreateMessageInternal< ::perfetto::protos::SchedProcessFreeFtraceEvent >(arena);
5882 }
5883 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedProcessHangFtraceEvent*
CreateMaybeMessage(Arena * arena)5884 Arena::CreateMaybeMessage< ::perfetto::protos::SchedProcessHangFtraceEvent >(Arena* arena) {
5885   return Arena::CreateMessageInternal< ::perfetto::protos::SchedProcessHangFtraceEvent >(arena);
5886 }
5887 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedProcessWaitFtraceEvent*
CreateMaybeMessage(Arena * arena)5888 Arena::CreateMaybeMessage< ::perfetto::protos::SchedProcessWaitFtraceEvent >(Arena* arena) {
5889   return Arena::CreateMessageInternal< ::perfetto::protos::SchedProcessWaitFtraceEvent >(arena);
5890 }
5891 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedPiSetprioFtraceEvent*
CreateMaybeMessage(Arena * arena)5892 Arena::CreateMaybeMessage< ::perfetto::protos::SchedPiSetprioFtraceEvent >(Arena* arena) {
5893   return Arena::CreateMessageInternal< ::perfetto::protos::SchedPiSetprioFtraceEvent >(arena);
5894 }
5895 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedCpuUtilCfsFtraceEvent*
CreateMaybeMessage(Arena * arena)5896 Arena::CreateMaybeMessage< ::perfetto::protos::SchedCpuUtilCfsFtraceEvent >(Arena* arena) {
5897   return Arena::CreateMessageInternal< ::perfetto::protos::SchedCpuUtilCfsFtraceEvent >(arena);
5898 }
5899 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedMigrateTaskFtraceEvent*
CreateMaybeMessage(Arena * arena)5900 Arena::CreateMaybeMessage< ::perfetto::protos::SchedMigrateTaskFtraceEvent >(Arena* arena) {
5901   return Arena::CreateMessageInternal< ::perfetto::protos::SchedMigrateTaskFtraceEvent >(arena);
5902 }
5903 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedWakeupTaskAttrFtraceEvent*
CreateMaybeMessage(Arena * arena)5904 Arena::CreateMaybeMessage< ::perfetto::protos::SchedWakeupTaskAttrFtraceEvent >(Arena* arena) {
5905   return Arena::CreateMessageInternal< ::perfetto::protos::SchedWakeupTaskAttrFtraceEvent >(arena);
5906 }
5907 PROTOBUF_NAMESPACE_CLOSE
5908 
5909 // @@protoc_insertion_point(global_scope)
5910 #include <google/protobuf/port_undef.inc>
5911