1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/mdss.proto
3
4 #include "protos/perfetto/trace/ftrace/mdss.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 {
MdpCmdKickoffFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR MdpCmdKickoffFtraceEvent::MdpCmdKickoffFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.ctl_num_)*/0u
28 , /*decltype(_impl_.kickoff_cnt_)*/0} {}
29 struct MdpCmdKickoffFtraceEventDefaultTypeInternal {
MdpCmdKickoffFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdKickoffFtraceEventDefaultTypeInternal30 PROTOBUF_CONSTEXPR MdpCmdKickoffFtraceEventDefaultTypeInternal()
31 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCmdKickoffFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdKickoffFtraceEventDefaultTypeInternal32 ~MdpCmdKickoffFtraceEventDefaultTypeInternal() {}
33 union { // NOLINT(misc-non-private-member-variables-in-classes)
34 MdpCmdKickoffFtraceEvent _instance;
35 };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCmdKickoffFtraceEventDefaultTypeInternal _MdpCmdKickoffFtraceEvent_default_instance_;
MdpCommitFtraceEvent(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR MdpCommitFtraceEvent::MdpCommitFtraceEvent(
39 ::_pbi::ConstantInitialized): _impl_{
40 /*decltype(_impl_._has_bits_)*/{}
41 , /*decltype(_impl_._cached_size_)*/{}
42 , /*decltype(_impl_.num_)*/0u
43 , /*decltype(_impl_.play_cnt_)*/0u
44 , /*decltype(_impl_.bandwidth_)*/::uint64_t{0u}
45 , /*decltype(_impl_.clk_rate_)*/0u} {}
46 struct MdpCommitFtraceEventDefaultTypeInternal {
MdpCommitFtraceEventDefaultTypeInternalperfetto::protos::MdpCommitFtraceEventDefaultTypeInternal47 PROTOBUF_CONSTEXPR MdpCommitFtraceEventDefaultTypeInternal()
48 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCommitFtraceEventDefaultTypeInternalperfetto::protos::MdpCommitFtraceEventDefaultTypeInternal49 ~MdpCommitFtraceEventDefaultTypeInternal() {}
50 union { // NOLINT(misc-non-private-member-variables-in-classes)
51 MdpCommitFtraceEvent _instance;
52 };
53 };
54 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCommitFtraceEventDefaultTypeInternal _MdpCommitFtraceEvent_default_instance_;
MdpPerfSetOtFtraceEvent(::_pbi::ConstantInitialized)55 PROTOBUF_CONSTEXPR MdpPerfSetOtFtraceEvent::MdpPerfSetOtFtraceEvent(
56 ::_pbi::ConstantInitialized): _impl_{
57 /*decltype(_impl_._has_bits_)*/{}
58 , /*decltype(_impl_._cached_size_)*/{}
59 , /*decltype(_impl_.pnum_)*/0u
60 , /*decltype(_impl_.xin_id_)*/0u
61 , /*decltype(_impl_.rd_lim_)*/0u
62 , /*decltype(_impl_.is_vbif_rt_)*/0u} {}
63 struct MdpPerfSetOtFtraceEventDefaultTypeInternal {
MdpPerfSetOtFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetOtFtraceEventDefaultTypeInternal64 PROTOBUF_CONSTEXPR MdpPerfSetOtFtraceEventDefaultTypeInternal()
65 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpPerfSetOtFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetOtFtraceEventDefaultTypeInternal66 ~MdpPerfSetOtFtraceEventDefaultTypeInternal() {}
67 union { // NOLINT(misc-non-private-member-variables-in-classes)
68 MdpPerfSetOtFtraceEvent _instance;
69 };
70 };
71 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpPerfSetOtFtraceEventDefaultTypeInternal _MdpPerfSetOtFtraceEvent_default_instance_;
MdpSsppChangeFtraceEvent(::_pbi::ConstantInitialized)72 PROTOBUF_CONSTEXPR MdpSsppChangeFtraceEvent::MdpSsppChangeFtraceEvent(
73 ::_pbi::ConstantInitialized): _impl_{
74 /*decltype(_impl_._has_bits_)*/{}
75 , /*decltype(_impl_._cached_size_)*/{}
76 , /*decltype(_impl_.num_)*/0u
77 , /*decltype(_impl_.play_cnt_)*/0u
78 , /*decltype(_impl_.mixer_)*/0u
79 , /*decltype(_impl_.stage_)*/0u
80 , /*decltype(_impl_.flags_)*/0u
81 , /*decltype(_impl_.format_)*/0u
82 , /*decltype(_impl_.img_w_)*/0u
83 , /*decltype(_impl_.img_h_)*/0u
84 , /*decltype(_impl_.src_x_)*/0u
85 , /*decltype(_impl_.src_y_)*/0u
86 , /*decltype(_impl_.src_w_)*/0u
87 , /*decltype(_impl_.src_h_)*/0u
88 , /*decltype(_impl_.dst_x_)*/0u
89 , /*decltype(_impl_.dst_y_)*/0u
90 , /*decltype(_impl_.dst_w_)*/0u
91 , /*decltype(_impl_.dst_h_)*/0u} {}
92 struct MdpSsppChangeFtraceEventDefaultTypeInternal {
MdpSsppChangeFtraceEventDefaultTypeInternalperfetto::protos::MdpSsppChangeFtraceEventDefaultTypeInternal93 PROTOBUF_CONSTEXPR MdpSsppChangeFtraceEventDefaultTypeInternal()
94 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpSsppChangeFtraceEventDefaultTypeInternalperfetto::protos::MdpSsppChangeFtraceEventDefaultTypeInternal95 ~MdpSsppChangeFtraceEventDefaultTypeInternal() {}
96 union { // NOLINT(misc-non-private-member-variables-in-classes)
97 MdpSsppChangeFtraceEvent _instance;
98 };
99 };
100 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpSsppChangeFtraceEventDefaultTypeInternal _MdpSsppChangeFtraceEvent_default_instance_;
TracingMarkWriteFtraceEvent(::_pbi::ConstantInitialized)101 PROTOBUF_CONSTEXPR TracingMarkWriteFtraceEvent::TracingMarkWriteFtraceEvent(
102 ::_pbi::ConstantInitialized): _impl_{
103 /*decltype(_impl_._has_bits_)*/{}
104 , /*decltype(_impl_._cached_size_)*/{}
105 , /*decltype(_impl_.trace_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
106 , /*decltype(_impl_.pid_)*/0
107 , /*decltype(_impl_.trace_begin_)*/0u} {}
108 struct TracingMarkWriteFtraceEventDefaultTypeInternal {
TracingMarkWriteFtraceEventDefaultTypeInternalperfetto::protos::TracingMarkWriteFtraceEventDefaultTypeInternal109 PROTOBUF_CONSTEXPR TracingMarkWriteFtraceEventDefaultTypeInternal()
110 : _instance(::_pbi::ConstantInitialized{}) {}
~TracingMarkWriteFtraceEventDefaultTypeInternalperfetto::protos::TracingMarkWriteFtraceEventDefaultTypeInternal111 ~TracingMarkWriteFtraceEventDefaultTypeInternal() {}
112 union { // NOLINT(misc-non-private-member-variables-in-classes)
113 TracingMarkWriteFtraceEvent _instance;
114 };
115 };
116 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingMarkWriteFtraceEventDefaultTypeInternal _TracingMarkWriteFtraceEvent_default_instance_;
MdpCmdPingpongDoneFtraceEvent(::_pbi::ConstantInitialized)117 PROTOBUF_CONSTEXPR MdpCmdPingpongDoneFtraceEvent::MdpCmdPingpongDoneFtraceEvent(
118 ::_pbi::ConstantInitialized): _impl_{
119 /*decltype(_impl_._has_bits_)*/{}
120 , /*decltype(_impl_._cached_size_)*/{}
121 , /*decltype(_impl_.ctl_num_)*/0u
122 , /*decltype(_impl_.intf_num_)*/0u
123 , /*decltype(_impl_.pp_num_)*/0u
124 , /*decltype(_impl_.koff_cnt_)*/0} {}
125 struct MdpCmdPingpongDoneFtraceEventDefaultTypeInternal {
MdpCmdPingpongDoneFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdPingpongDoneFtraceEventDefaultTypeInternal126 PROTOBUF_CONSTEXPR MdpCmdPingpongDoneFtraceEventDefaultTypeInternal()
127 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCmdPingpongDoneFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdPingpongDoneFtraceEventDefaultTypeInternal128 ~MdpCmdPingpongDoneFtraceEventDefaultTypeInternal() {}
129 union { // NOLINT(misc-non-private-member-variables-in-classes)
130 MdpCmdPingpongDoneFtraceEvent _instance;
131 };
132 };
133 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCmdPingpongDoneFtraceEventDefaultTypeInternal _MdpCmdPingpongDoneFtraceEvent_default_instance_;
MdpCompareBwFtraceEvent(::_pbi::ConstantInitialized)134 PROTOBUF_CONSTEXPR MdpCompareBwFtraceEvent::MdpCompareBwFtraceEvent(
135 ::_pbi::ConstantInitialized): _impl_{
136 /*decltype(_impl_._has_bits_)*/{}
137 , /*decltype(_impl_._cached_size_)*/{}
138 , /*decltype(_impl_.new_ab_)*/::uint64_t{0u}
139 , /*decltype(_impl_.new_ib_)*/::uint64_t{0u}
140 , /*decltype(_impl_.new_wb_)*/::uint64_t{0u}
141 , /*decltype(_impl_.old_ab_)*/::uint64_t{0u}
142 , /*decltype(_impl_.old_ib_)*/::uint64_t{0u}
143 , /*decltype(_impl_.old_wb_)*/::uint64_t{0u}
144 , /*decltype(_impl_.params_changed_)*/0u
145 , /*decltype(_impl_.update_bw_)*/0u} {}
146 struct MdpCompareBwFtraceEventDefaultTypeInternal {
MdpCompareBwFtraceEventDefaultTypeInternalperfetto::protos::MdpCompareBwFtraceEventDefaultTypeInternal147 PROTOBUF_CONSTEXPR MdpCompareBwFtraceEventDefaultTypeInternal()
148 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCompareBwFtraceEventDefaultTypeInternalperfetto::protos::MdpCompareBwFtraceEventDefaultTypeInternal149 ~MdpCompareBwFtraceEventDefaultTypeInternal() {}
150 union { // NOLINT(misc-non-private-member-variables-in-classes)
151 MdpCompareBwFtraceEvent _instance;
152 };
153 };
154 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCompareBwFtraceEventDefaultTypeInternal _MdpCompareBwFtraceEvent_default_instance_;
MdpPerfSetPanicLutsFtraceEvent(::_pbi::ConstantInitialized)155 PROTOBUF_CONSTEXPR MdpPerfSetPanicLutsFtraceEvent::MdpPerfSetPanicLutsFtraceEvent(
156 ::_pbi::ConstantInitialized): _impl_{
157 /*decltype(_impl_._has_bits_)*/{}
158 , /*decltype(_impl_._cached_size_)*/{}
159 , /*decltype(_impl_.pnum_)*/0u
160 , /*decltype(_impl_.fmt_)*/0u
161 , /*decltype(_impl_.mode_)*/0u
162 , /*decltype(_impl_.panic_lut_)*/0u
163 , /*decltype(_impl_.robust_lut_)*/0u} {}
164 struct MdpPerfSetPanicLutsFtraceEventDefaultTypeInternal {
MdpPerfSetPanicLutsFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetPanicLutsFtraceEventDefaultTypeInternal165 PROTOBUF_CONSTEXPR MdpPerfSetPanicLutsFtraceEventDefaultTypeInternal()
166 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpPerfSetPanicLutsFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetPanicLutsFtraceEventDefaultTypeInternal167 ~MdpPerfSetPanicLutsFtraceEventDefaultTypeInternal() {}
168 union { // NOLINT(misc-non-private-member-variables-in-classes)
169 MdpPerfSetPanicLutsFtraceEvent _instance;
170 };
171 };
172 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpPerfSetPanicLutsFtraceEventDefaultTypeInternal _MdpPerfSetPanicLutsFtraceEvent_default_instance_;
MdpSsppSetFtraceEvent(::_pbi::ConstantInitialized)173 PROTOBUF_CONSTEXPR MdpSsppSetFtraceEvent::MdpSsppSetFtraceEvent(
174 ::_pbi::ConstantInitialized): _impl_{
175 /*decltype(_impl_._has_bits_)*/{}
176 , /*decltype(_impl_._cached_size_)*/{}
177 , /*decltype(_impl_.num_)*/0u
178 , /*decltype(_impl_.play_cnt_)*/0u
179 , /*decltype(_impl_.mixer_)*/0u
180 , /*decltype(_impl_.stage_)*/0u
181 , /*decltype(_impl_.flags_)*/0u
182 , /*decltype(_impl_.format_)*/0u
183 , /*decltype(_impl_.img_w_)*/0u
184 , /*decltype(_impl_.img_h_)*/0u
185 , /*decltype(_impl_.src_x_)*/0u
186 , /*decltype(_impl_.src_y_)*/0u
187 , /*decltype(_impl_.src_w_)*/0u
188 , /*decltype(_impl_.src_h_)*/0u
189 , /*decltype(_impl_.dst_x_)*/0u
190 , /*decltype(_impl_.dst_y_)*/0u
191 , /*decltype(_impl_.dst_w_)*/0u
192 , /*decltype(_impl_.dst_h_)*/0u} {}
193 struct MdpSsppSetFtraceEventDefaultTypeInternal {
MdpSsppSetFtraceEventDefaultTypeInternalperfetto::protos::MdpSsppSetFtraceEventDefaultTypeInternal194 PROTOBUF_CONSTEXPR MdpSsppSetFtraceEventDefaultTypeInternal()
195 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpSsppSetFtraceEventDefaultTypeInternalperfetto::protos::MdpSsppSetFtraceEventDefaultTypeInternal196 ~MdpSsppSetFtraceEventDefaultTypeInternal() {}
197 union { // NOLINT(misc-non-private-member-variables-in-classes)
198 MdpSsppSetFtraceEvent _instance;
199 };
200 };
201 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpSsppSetFtraceEventDefaultTypeInternal _MdpSsppSetFtraceEvent_default_instance_;
MdpCmdReadptrDoneFtraceEvent(::_pbi::ConstantInitialized)202 PROTOBUF_CONSTEXPR MdpCmdReadptrDoneFtraceEvent::MdpCmdReadptrDoneFtraceEvent(
203 ::_pbi::ConstantInitialized): _impl_{
204 /*decltype(_impl_._has_bits_)*/{}
205 , /*decltype(_impl_._cached_size_)*/{}
206 , /*decltype(_impl_.ctl_num_)*/0u
207 , /*decltype(_impl_.koff_cnt_)*/0} {}
208 struct MdpCmdReadptrDoneFtraceEventDefaultTypeInternal {
MdpCmdReadptrDoneFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdReadptrDoneFtraceEventDefaultTypeInternal209 PROTOBUF_CONSTEXPR MdpCmdReadptrDoneFtraceEventDefaultTypeInternal()
210 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCmdReadptrDoneFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdReadptrDoneFtraceEventDefaultTypeInternal211 ~MdpCmdReadptrDoneFtraceEventDefaultTypeInternal() {}
212 union { // NOLINT(misc-non-private-member-variables-in-classes)
213 MdpCmdReadptrDoneFtraceEvent _instance;
214 };
215 };
216 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCmdReadptrDoneFtraceEventDefaultTypeInternal _MdpCmdReadptrDoneFtraceEvent_default_instance_;
MdpMisrCrcFtraceEvent(::_pbi::ConstantInitialized)217 PROTOBUF_CONSTEXPR MdpMisrCrcFtraceEvent::MdpMisrCrcFtraceEvent(
218 ::_pbi::ConstantInitialized): _impl_{
219 /*decltype(_impl_._has_bits_)*/{}
220 , /*decltype(_impl_._cached_size_)*/{}
221 , /*decltype(_impl_.block_id_)*/0u
222 , /*decltype(_impl_.vsync_cnt_)*/0u
223 , /*decltype(_impl_.crc_)*/0u} {}
224 struct MdpMisrCrcFtraceEventDefaultTypeInternal {
MdpMisrCrcFtraceEventDefaultTypeInternalperfetto::protos::MdpMisrCrcFtraceEventDefaultTypeInternal225 PROTOBUF_CONSTEXPR MdpMisrCrcFtraceEventDefaultTypeInternal()
226 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpMisrCrcFtraceEventDefaultTypeInternalperfetto::protos::MdpMisrCrcFtraceEventDefaultTypeInternal227 ~MdpMisrCrcFtraceEventDefaultTypeInternal() {}
228 union { // NOLINT(misc-non-private-member-variables-in-classes)
229 MdpMisrCrcFtraceEvent _instance;
230 };
231 };
232 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpMisrCrcFtraceEventDefaultTypeInternal _MdpMisrCrcFtraceEvent_default_instance_;
MdpPerfSetQosLutsFtraceEvent(::_pbi::ConstantInitialized)233 PROTOBUF_CONSTEXPR MdpPerfSetQosLutsFtraceEvent::MdpPerfSetQosLutsFtraceEvent(
234 ::_pbi::ConstantInitialized): _impl_{
235 /*decltype(_impl_._has_bits_)*/{}
236 , /*decltype(_impl_._cached_size_)*/{}
237 , /*decltype(_impl_.pnum_)*/0u
238 , /*decltype(_impl_.fmt_)*/0u
239 , /*decltype(_impl_.intf_)*/0u
240 , /*decltype(_impl_.rot_)*/0u
241 , /*decltype(_impl_.fl_)*/0u
242 , /*decltype(_impl_.lut_)*/0u
243 , /*decltype(_impl_.linear_)*/0u} {}
244 struct MdpPerfSetQosLutsFtraceEventDefaultTypeInternal {
MdpPerfSetQosLutsFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetQosLutsFtraceEventDefaultTypeInternal245 PROTOBUF_CONSTEXPR MdpPerfSetQosLutsFtraceEventDefaultTypeInternal()
246 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpPerfSetQosLutsFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetQosLutsFtraceEventDefaultTypeInternal247 ~MdpPerfSetQosLutsFtraceEventDefaultTypeInternal() {}
248 union { // NOLINT(misc-non-private-member-variables-in-classes)
249 MdpPerfSetQosLutsFtraceEvent _instance;
250 };
251 };
252 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpPerfSetQosLutsFtraceEventDefaultTypeInternal _MdpPerfSetQosLutsFtraceEvent_default_instance_;
MdpTraceCounterFtraceEvent(::_pbi::ConstantInitialized)253 PROTOBUF_CONSTEXPR MdpTraceCounterFtraceEvent::MdpTraceCounterFtraceEvent(
254 ::_pbi::ConstantInitialized): _impl_{
255 /*decltype(_impl_._has_bits_)*/{}
256 , /*decltype(_impl_._cached_size_)*/{}
257 , /*decltype(_impl_.counter_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
258 , /*decltype(_impl_.pid_)*/0
259 , /*decltype(_impl_.value_)*/0} {}
260 struct MdpTraceCounterFtraceEventDefaultTypeInternal {
MdpTraceCounterFtraceEventDefaultTypeInternalperfetto::protos::MdpTraceCounterFtraceEventDefaultTypeInternal261 PROTOBUF_CONSTEXPR MdpTraceCounterFtraceEventDefaultTypeInternal()
262 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpTraceCounterFtraceEventDefaultTypeInternalperfetto::protos::MdpTraceCounterFtraceEventDefaultTypeInternal263 ~MdpTraceCounterFtraceEventDefaultTypeInternal() {}
264 union { // NOLINT(misc-non-private-member-variables-in-classes)
265 MdpTraceCounterFtraceEvent _instance;
266 };
267 };
268 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpTraceCounterFtraceEventDefaultTypeInternal _MdpTraceCounterFtraceEvent_default_instance_;
MdpCmdReleaseBwFtraceEvent(::_pbi::ConstantInitialized)269 PROTOBUF_CONSTEXPR MdpCmdReleaseBwFtraceEvent::MdpCmdReleaseBwFtraceEvent(
270 ::_pbi::ConstantInitialized): _impl_{
271 /*decltype(_impl_._has_bits_)*/{}
272 , /*decltype(_impl_._cached_size_)*/{}
273 , /*decltype(_impl_.ctl_num_)*/0u} {}
274 struct MdpCmdReleaseBwFtraceEventDefaultTypeInternal {
MdpCmdReleaseBwFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdReleaseBwFtraceEventDefaultTypeInternal275 PROTOBUF_CONSTEXPR MdpCmdReleaseBwFtraceEventDefaultTypeInternal()
276 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCmdReleaseBwFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdReleaseBwFtraceEventDefaultTypeInternal277 ~MdpCmdReleaseBwFtraceEventDefaultTypeInternal() {}
278 union { // NOLINT(misc-non-private-member-variables-in-classes)
279 MdpCmdReleaseBwFtraceEvent _instance;
280 };
281 };
282 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCmdReleaseBwFtraceEventDefaultTypeInternal _MdpCmdReleaseBwFtraceEvent_default_instance_;
MdpMixerUpdateFtraceEvent(::_pbi::ConstantInitialized)283 PROTOBUF_CONSTEXPR MdpMixerUpdateFtraceEvent::MdpMixerUpdateFtraceEvent(
284 ::_pbi::ConstantInitialized): _impl_{
285 /*decltype(_impl_._has_bits_)*/{}
286 , /*decltype(_impl_._cached_size_)*/{}
287 , /*decltype(_impl_.mixer_num_)*/0u} {}
288 struct MdpMixerUpdateFtraceEventDefaultTypeInternal {
MdpMixerUpdateFtraceEventDefaultTypeInternalperfetto::protos::MdpMixerUpdateFtraceEventDefaultTypeInternal289 PROTOBUF_CONSTEXPR MdpMixerUpdateFtraceEventDefaultTypeInternal()
290 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpMixerUpdateFtraceEventDefaultTypeInternalperfetto::protos::MdpMixerUpdateFtraceEventDefaultTypeInternal291 ~MdpMixerUpdateFtraceEventDefaultTypeInternal() {}
292 union { // NOLINT(misc-non-private-member-variables-in-classes)
293 MdpMixerUpdateFtraceEvent _instance;
294 };
295 };
296 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpMixerUpdateFtraceEventDefaultTypeInternal _MdpMixerUpdateFtraceEvent_default_instance_;
MdpPerfSetWmLevelsFtraceEvent(::_pbi::ConstantInitialized)297 PROTOBUF_CONSTEXPR MdpPerfSetWmLevelsFtraceEvent::MdpPerfSetWmLevelsFtraceEvent(
298 ::_pbi::ConstantInitialized): _impl_{
299 /*decltype(_impl_._has_bits_)*/{}
300 , /*decltype(_impl_._cached_size_)*/{}
301 , /*decltype(_impl_.pnum_)*/0u
302 , /*decltype(_impl_.use_space_)*/0u
303 , /*decltype(_impl_.priority_bytes_)*/0u
304 , /*decltype(_impl_.wm0_)*/0u
305 , /*decltype(_impl_.wm1_)*/0u
306 , /*decltype(_impl_.wm2_)*/0u
307 , /*decltype(_impl_.mb_cnt_)*/0u
308 , /*decltype(_impl_.mb_size_)*/0u} {}
309 struct MdpPerfSetWmLevelsFtraceEventDefaultTypeInternal {
MdpPerfSetWmLevelsFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetWmLevelsFtraceEventDefaultTypeInternal310 PROTOBUF_CONSTEXPR MdpPerfSetWmLevelsFtraceEventDefaultTypeInternal()
311 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpPerfSetWmLevelsFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfSetWmLevelsFtraceEventDefaultTypeInternal312 ~MdpPerfSetWmLevelsFtraceEventDefaultTypeInternal() {}
313 union { // NOLINT(misc-non-private-member-variables-in-classes)
314 MdpPerfSetWmLevelsFtraceEvent _instance;
315 };
316 };
317 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpPerfSetWmLevelsFtraceEventDefaultTypeInternal _MdpPerfSetWmLevelsFtraceEvent_default_instance_;
MdpVideoUnderrunDoneFtraceEvent(::_pbi::ConstantInitialized)318 PROTOBUF_CONSTEXPR MdpVideoUnderrunDoneFtraceEvent::MdpVideoUnderrunDoneFtraceEvent(
319 ::_pbi::ConstantInitialized): _impl_{
320 /*decltype(_impl_._has_bits_)*/{}
321 , /*decltype(_impl_._cached_size_)*/{}
322 , /*decltype(_impl_.ctl_num_)*/0u
323 , /*decltype(_impl_.underrun_cnt_)*/0u} {}
324 struct MdpVideoUnderrunDoneFtraceEventDefaultTypeInternal {
MdpVideoUnderrunDoneFtraceEventDefaultTypeInternalperfetto::protos::MdpVideoUnderrunDoneFtraceEventDefaultTypeInternal325 PROTOBUF_CONSTEXPR MdpVideoUnderrunDoneFtraceEventDefaultTypeInternal()
326 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpVideoUnderrunDoneFtraceEventDefaultTypeInternalperfetto::protos::MdpVideoUnderrunDoneFtraceEventDefaultTypeInternal327 ~MdpVideoUnderrunDoneFtraceEventDefaultTypeInternal() {}
328 union { // NOLINT(misc-non-private-member-variables-in-classes)
329 MdpVideoUnderrunDoneFtraceEvent _instance;
330 };
331 };
332 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpVideoUnderrunDoneFtraceEventDefaultTypeInternal _MdpVideoUnderrunDoneFtraceEvent_default_instance_;
MdpCmdWaitPingpongFtraceEvent(::_pbi::ConstantInitialized)333 PROTOBUF_CONSTEXPR MdpCmdWaitPingpongFtraceEvent::MdpCmdWaitPingpongFtraceEvent(
334 ::_pbi::ConstantInitialized): _impl_{
335 /*decltype(_impl_._has_bits_)*/{}
336 , /*decltype(_impl_._cached_size_)*/{}
337 , /*decltype(_impl_.ctl_num_)*/0u
338 , /*decltype(_impl_.kickoff_cnt_)*/0} {}
339 struct MdpCmdWaitPingpongFtraceEventDefaultTypeInternal {
MdpCmdWaitPingpongFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdWaitPingpongFtraceEventDefaultTypeInternal340 PROTOBUF_CONSTEXPR MdpCmdWaitPingpongFtraceEventDefaultTypeInternal()
341 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpCmdWaitPingpongFtraceEventDefaultTypeInternalperfetto::protos::MdpCmdWaitPingpongFtraceEventDefaultTypeInternal342 ~MdpCmdWaitPingpongFtraceEventDefaultTypeInternal() {}
343 union { // NOLINT(misc-non-private-member-variables-in-classes)
344 MdpCmdWaitPingpongFtraceEvent _instance;
345 };
346 };
347 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpCmdWaitPingpongFtraceEventDefaultTypeInternal _MdpCmdWaitPingpongFtraceEvent_default_instance_;
MdpPerfPrefillCalcFtraceEvent(::_pbi::ConstantInitialized)348 PROTOBUF_CONSTEXPR MdpPerfPrefillCalcFtraceEvent::MdpPerfPrefillCalcFtraceEvent(
349 ::_pbi::ConstantInitialized): _impl_{
350 /*decltype(_impl_._has_bits_)*/{}
351 , /*decltype(_impl_._cached_size_)*/{}
352 , /*decltype(_impl_.pnum_)*/0u
353 , /*decltype(_impl_.latency_buf_)*/0u
354 , /*decltype(_impl_.ot_)*/0u
355 , /*decltype(_impl_.y_buf_)*/0u
356 , /*decltype(_impl_.y_scaler_)*/0u
357 , /*decltype(_impl_.pp_lines_)*/0u
358 , /*decltype(_impl_.pp_bytes_)*/0u
359 , /*decltype(_impl_.post_sc_)*/0u
360 , /*decltype(_impl_.fbc_bytes_)*/0u
361 , /*decltype(_impl_.prefill_bytes_)*/0u} {}
362 struct MdpPerfPrefillCalcFtraceEventDefaultTypeInternal {
MdpPerfPrefillCalcFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfPrefillCalcFtraceEventDefaultTypeInternal363 PROTOBUF_CONSTEXPR MdpPerfPrefillCalcFtraceEventDefaultTypeInternal()
364 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpPerfPrefillCalcFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfPrefillCalcFtraceEventDefaultTypeInternal365 ~MdpPerfPrefillCalcFtraceEventDefaultTypeInternal() {}
366 union { // NOLINT(misc-non-private-member-variables-in-classes)
367 MdpPerfPrefillCalcFtraceEvent _instance;
368 };
369 };
370 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpPerfPrefillCalcFtraceEventDefaultTypeInternal _MdpPerfPrefillCalcFtraceEvent_default_instance_;
MdpPerfUpdateBusFtraceEvent(::_pbi::ConstantInitialized)371 PROTOBUF_CONSTEXPR MdpPerfUpdateBusFtraceEvent::MdpPerfUpdateBusFtraceEvent(
372 ::_pbi::ConstantInitialized): _impl_{
373 /*decltype(_impl_._has_bits_)*/{}
374 , /*decltype(_impl_._cached_size_)*/{}
375 , /*decltype(_impl_.ab_quota_)*/::uint64_t{0u}
376 , /*decltype(_impl_.ib_quota_)*/::uint64_t{0u}
377 , /*decltype(_impl_.client_)*/0} {}
378 struct MdpPerfUpdateBusFtraceEventDefaultTypeInternal {
MdpPerfUpdateBusFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfUpdateBusFtraceEventDefaultTypeInternal379 PROTOBUF_CONSTEXPR MdpPerfUpdateBusFtraceEventDefaultTypeInternal()
380 : _instance(::_pbi::ConstantInitialized{}) {}
~MdpPerfUpdateBusFtraceEventDefaultTypeInternalperfetto::protos::MdpPerfUpdateBusFtraceEventDefaultTypeInternal381 ~MdpPerfUpdateBusFtraceEventDefaultTypeInternal() {}
382 union { // NOLINT(misc-non-private-member-variables-in-classes)
383 MdpPerfUpdateBusFtraceEvent _instance;
384 };
385 };
386 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MdpPerfUpdateBusFtraceEventDefaultTypeInternal _MdpPerfUpdateBusFtraceEvent_default_instance_;
RotatorBwAoAsContextFtraceEvent(::_pbi::ConstantInitialized)387 PROTOBUF_CONSTEXPR RotatorBwAoAsContextFtraceEvent::RotatorBwAoAsContextFtraceEvent(
388 ::_pbi::ConstantInitialized): _impl_{
389 /*decltype(_impl_._has_bits_)*/{}
390 , /*decltype(_impl_._cached_size_)*/{}
391 , /*decltype(_impl_.state_)*/0u} {}
392 struct RotatorBwAoAsContextFtraceEventDefaultTypeInternal {
RotatorBwAoAsContextFtraceEventDefaultTypeInternalperfetto::protos::RotatorBwAoAsContextFtraceEventDefaultTypeInternal393 PROTOBUF_CONSTEXPR RotatorBwAoAsContextFtraceEventDefaultTypeInternal()
394 : _instance(::_pbi::ConstantInitialized{}) {}
~RotatorBwAoAsContextFtraceEventDefaultTypeInternalperfetto::protos::RotatorBwAoAsContextFtraceEventDefaultTypeInternal395 ~RotatorBwAoAsContextFtraceEventDefaultTypeInternal() {}
396 union { // NOLINT(misc-non-private-member-variables-in-classes)
397 RotatorBwAoAsContextFtraceEvent _instance;
398 };
399 };
400 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RotatorBwAoAsContextFtraceEventDefaultTypeInternal _RotatorBwAoAsContextFtraceEvent_default_instance_;
401 } // namespace protos
402 } // namespace perfetto
403 namespace perfetto {
404 namespace protos {
405
406 // ===================================================================
407
408 class MdpCmdKickoffFtraceEvent::_Internal {
409 public:
410 using HasBits = decltype(std::declval<MdpCmdKickoffFtraceEvent>()._impl_._has_bits_);
set_has_ctl_num(HasBits * has_bits)411 static void set_has_ctl_num(HasBits* has_bits) {
412 (*has_bits)[0] |= 1u;
413 }
set_has_kickoff_cnt(HasBits * has_bits)414 static void set_has_kickoff_cnt(HasBits* has_bits) {
415 (*has_bits)[0] |= 2u;
416 }
417 };
418
MdpCmdKickoffFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)419 MdpCmdKickoffFtraceEvent::MdpCmdKickoffFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
420 bool is_message_owned)
421 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
422 SharedCtor(arena, is_message_owned);
423 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCmdKickoffFtraceEvent)
424 }
MdpCmdKickoffFtraceEvent(const MdpCmdKickoffFtraceEvent & from)425 MdpCmdKickoffFtraceEvent::MdpCmdKickoffFtraceEvent(const MdpCmdKickoffFtraceEvent& from)
426 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
427 MdpCmdKickoffFtraceEvent* const _this = this; (void)_this;
428 new (&_impl_) Impl_{
429 decltype(_impl_._has_bits_){from._impl_._has_bits_}
430 , /*decltype(_impl_._cached_size_)*/{}
431 , decltype(_impl_.ctl_num_){}
432 , decltype(_impl_.kickoff_cnt_){}};
433
434 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
435 ::memcpy(&_impl_.ctl_num_, &from._impl_.ctl_num_,
436 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.kickoff_cnt_) -
437 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.kickoff_cnt_));
438 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCmdKickoffFtraceEvent)
439 }
440
SharedCtor(::_pb::Arena * arena,bool is_message_owned)441 inline void MdpCmdKickoffFtraceEvent::SharedCtor(
442 ::_pb::Arena* arena, bool is_message_owned) {
443 (void)arena;
444 (void)is_message_owned;
445 new (&_impl_) Impl_{
446 decltype(_impl_._has_bits_){}
447 , /*decltype(_impl_._cached_size_)*/{}
448 , decltype(_impl_.ctl_num_){0u}
449 , decltype(_impl_.kickoff_cnt_){0}
450 };
451 }
452
~MdpCmdKickoffFtraceEvent()453 MdpCmdKickoffFtraceEvent::~MdpCmdKickoffFtraceEvent() {
454 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCmdKickoffFtraceEvent)
455 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
456 (void)arena;
457 return;
458 }
459 SharedDtor();
460 }
461
SharedDtor()462 inline void MdpCmdKickoffFtraceEvent::SharedDtor() {
463 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
464 }
465
SetCachedSize(int size) const466 void MdpCmdKickoffFtraceEvent::SetCachedSize(int size) const {
467 _impl_._cached_size_.Set(size);
468 }
469
Clear()470 void MdpCmdKickoffFtraceEvent::Clear() {
471 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCmdKickoffFtraceEvent)
472 ::uint32_t cached_has_bits = 0;
473 // Prevent compiler warnings about cached_has_bits being unused
474 (void) cached_has_bits;
475
476 cached_has_bits = _impl_._has_bits_[0];
477 if (cached_has_bits & 0x00000003u) {
478 ::memset(&_impl_.ctl_num_, 0, static_cast<size_t>(
479 reinterpret_cast<char*>(&_impl_.kickoff_cnt_) -
480 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.kickoff_cnt_));
481 }
482 _impl_._has_bits_.Clear();
483 _internal_metadata_.Clear<std::string>();
484 }
485
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)486 const char* MdpCmdKickoffFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
487 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
488 _Internal::HasBits has_bits{};
489 while (!ctx->Done(&ptr)) {
490 ::uint32_t tag;
491 ptr = ::_pbi::ReadTag(ptr, &tag);
492 switch (tag >> 3) {
493 // optional uint32 ctl_num = 1;
494 case 1:
495 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
496 _Internal::set_has_ctl_num(&has_bits);
497 _impl_.ctl_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
498 CHK_(ptr);
499 } else {
500 goto handle_unusual;
501 }
502 continue;
503 // optional int32 kickoff_cnt = 2;
504 case 2:
505 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
506 _Internal::set_has_kickoff_cnt(&has_bits);
507 _impl_.kickoff_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
508 CHK_(ptr);
509 } else {
510 goto handle_unusual;
511 }
512 continue;
513 default:
514 goto handle_unusual;
515 } // switch
516 handle_unusual:
517 if ((tag == 0) || ((tag & 7) == 4)) {
518 CHK_(ptr);
519 ctx->SetLastTag(tag);
520 goto message_done;
521 }
522 ptr = UnknownFieldParse(
523 tag,
524 _internal_metadata_.mutable_unknown_fields<std::string>(),
525 ptr, ctx);
526 CHK_(ptr != nullptr);
527 } // while
528 message_done:
529 _impl_._has_bits_.Or(has_bits);
530 return ptr;
531 failure:
532 ptr = nullptr;
533 goto message_done;
534 #undef CHK_
535 }
536
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const537 ::uint8_t* MdpCmdKickoffFtraceEvent::_InternalSerialize(
538 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
539 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCmdKickoffFtraceEvent)
540 ::uint32_t cached_has_bits = 0;
541 (void) cached_has_bits;
542
543 cached_has_bits = _impl_._has_bits_[0];
544 // optional uint32 ctl_num = 1;
545 if (cached_has_bits & 0x00000001u) {
546 target = stream->EnsureSpace(target);
547 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ctl_num(), target);
548 }
549
550 // optional int32 kickoff_cnt = 2;
551 if (cached_has_bits & 0x00000002u) {
552 target = stream->EnsureSpace(target);
553 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_kickoff_cnt(), target);
554 }
555
556 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
557 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
558 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
559 }
560 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCmdKickoffFtraceEvent)
561 return target;
562 }
563
ByteSizeLong() const564 size_t MdpCmdKickoffFtraceEvent::ByteSizeLong() const {
565 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCmdKickoffFtraceEvent)
566 size_t total_size = 0;
567
568 ::uint32_t cached_has_bits = 0;
569 // Prevent compiler warnings about cached_has_bits being unused
570 (void) cached_has_bits;
571
572 cached_has_bits = _impl_._has_bits_[0];
573 if (cached_has_bits & 0x00000003u) {
574 // optional uint32 ctl_num = 1;
575 if (cached_has_bits & 0x00000001u) {
576 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ctl_num());
577 }
578
579 // optional int32 kickoff_cnt = 2;
580 if (cached_has_bits & 0x00000002u) {
581 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_kickoff_cnt());
582 }
583
584 }
585 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
586 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
587 }
588 int cached_size = ::_pbi::ToCachedSize(total_size);
589 SetCachedSize(cached_size);
590 return total_size;
591 }
592
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)593 void MdpCmdKickoffFtraceEvent::CheckTypeAndMergeFrom(
594 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
595 MergeFrom(*::_pbi::DownCast<const MdpCmdKickoffFtraceEvent*>(
596 &from));
597 }
598
MergeFrom(const MdpCmdKickoffFtraceEvent & from)599 void MdpCmdKickoffFtraceEvent::MergeFrom(const MdpCmdKickoffFtraceEvent& from) {
600 MdpCmdKickoffFtraceEvent* const _this = this;
601 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCmdKickoffFtraceEvent)
602 GOOGLE_DCHECK_NE(&from, _this);
603 ::uint32_t cached_has_bits = 0;
604 (void) cached_has_bits;
605
606 cached_has_bits = from._impl_._has_bits_[0];
607 if (cached_has_bits & 0x00000003u) {
608 if (cached_has_bits & 0x00000001u) {
609 _this->_impl_.ctl_num_ = from._impl_.ctl_num_;
610 }
611 if (cached_has_bits & 0x00000002u) {
612 _this->_impl_.kickoff_cnt_ = from._impl_.kickoff_cnt_;
613 }
614 _this->_impl_._has_bits_[0] |= cached_has_bits;
615 }
616 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
617 }
618
CopyFrom(const MdpCmdKickoffFtraceEvent & from)619 void MdpCmdKickoffFtraceEvent::CopyFrom(const MdpCmdKickoffFtraceEvent& from) {
620 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCmdKickoffFtraceEvent)
621 if (&from == this) return;
622 Clear();
623 MergeFrom(from);
624 }
625
IsInitialized() const626 bool MdpCmdKickoffFtraceEvent::IsInitialized() const {
627 return true;
628 }
629
InternalSwap(MdpCmdKickoffFtraceEvent * other)630 void MdpCmdKickoffFtraceEvent::InternalSwap(MdpCmdKickoffFtraceEvent* other) {
631 using std::swap;
632 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
633 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
634 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
635 PROTOBUF_FIELD_OFFSET(MdpCmdKickoffFtraceEvent, _impl_.kickoff_cnt_)
636 + sizeof(MdpCmdKickoffFtraceEvent::_impl_.kickoff_cnt_) // NOLINT
637 - PROTOBUF_FIELD_OFFSET(MdpCmdKickoffFtraceEvent, _impl_.ctl_num_)>(
638 reinterpret_cast<char*>(&_impl_.ctl_num_),
639 reinterpret_cast<char*>(&other->_impl_.ctl_num_));
640 }
641
GetTypeName() const642 std::string MdpCmdKickoffFtraceEvent::GetTypeName() const {
643 return "perfetto.protos.MdpCmdKickoffFtraceEvent";
644 }
645
646
647 // ===================================================================
648
649 class MdpCommitFtraceEvent::_Internal {
650 public:
651 using HasBits = decltype(std::declval<MdpCommitFtraceEvent>()._impl_._has_bits_);
set_has_num(HasBits * has_bits)652 static void set_has_num(HasBits* has_bits) {
653 (*has_bits)[0] |= 1u;
654 }
set_has_play_cnt(HasBits * has_bits)655 static void set_has_play_cnt(HasBits* has_bits) {
656 (*has_bits)[0] |= 2u;
657 }
set_has_clk_rate(HasBits * has_bits)658 static void set_has_clk_rate(HasBits* has_bits) {
659 (*has_bits)[0] |= 8u;
660 }
set_has_bandwidth(HasBits * has_bits)661 static void set_has_bandwidth(HasBits* has_bits) {
662 (*has_bits)[0] |= 4u;
663 }
664 };
665
MdpCommitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)666 MdpCommitFtraceEvent::MdpCommitFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
667 bool is_message_owned)
668 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
669 SharedCtor(arena, is_message_owned);
670 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCommitFtraceEvent)
671 }
MdpCommitFtraceEvent(const MdpCommitFtraceEvent & from)672 MdpCommitFtraceEvent::MdpCommitFtraceEvent(const MdpCommitFtraceEvent& from)
673 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
674 MdpCommitFtraceEvent* const _this = this; (void)_this;
675 new (&_impl_) Impl_{
676 decltype(_impl_._has_bits_){from._impl_._has_bits_}
677 , /*decltype(_impl_._cached_size_)*/{}
678 , decltype(_impl_.num_){}
679 , decltype(_impl_.play_cnt_){}
680 , decltype(_impl_.bandwidth_){}
681 , decltype(_impl_.clk_rate_){}};
682
683 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
684 ::memcpy(&_impl_.num_, &from._impl_.num_,
685 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.clk_rate_) -
686 reinterpret_cast<char*>(&_impl_.num_)) + sizeof(_impl_.clk_rate_));
687 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCommitFtraceEvent)
688 }
689
SharedCtor(::_pb::Arena * arena,bool is_message_owned)690 inline void MdpCommitFtraceEvent::SharedCtor(
691 ::_pb::Arena* arena, bool is_message_owned) {
692 (void)arena;
693 (void)is_message_owned;
694 new (&_impl_) Impl_{
695 decltype(_impl_._has_bits_){}
696 , /*decltype(_impl_._cached_size_)*/{}
697 , decltype(_impl_.num_){0u}
698 , decltype(_impl_.play_cnt_){0u}
699 , decltype(_impl_.bandwidth_){::uint64_t{0u}}
700 , decltype(_impl_.clk_rate_){0u}
701 };
702 }
703
~MdpCommitFtraceEvent()704 MdpCommitFtraceEvent::~MdpCommitFtraceEvent() {
705 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCommitFtraceEvent)
706 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
707 (void)arena;
708 return;
709 }
710 SharedDtor();
711 }
712
SharedDtor()713 inline void MdpCommitFtraceEvent::SharedDtor() {
714 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
715 }
716
SetCachedSize(int size) const717 void MdpCommitFtraceEvent::SetCachedSize(int size) const {
718 _impl_._cached_size_.Set(size);
719 }
720
Clear()721 void MdpCommitFtraceEvent::Clear() {
722 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCommitFtraceEvent)
723 ::uint32_t cached_has_bits = 0;
724 // Prevent compiler warnings about cached_has_bits being unused
725 (void) cached_has_bits;
726
727 cached_has_bits = _impl_._has_bits_[0];
728 if (cached_has_bits & 0x0000000fu) {
729 ::memset(&_impl_.num_, 0, static_cast<size_t>(
730 reinterpret_cast<char*>(&_impl_.clk_rate_) -
731 reinterpret_cast<char*>(&_impl_.num_)) + sizeof(_impl_.clk_rate_));
732 }
733 _impl_._has_bits_.Clear();
734 _internal_metadata_.Clear<std::string>();
735 }
736
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)737 const char* MdpCommitFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
738 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
739 _Internal::HasBits has_bits{};
740 while (!ctx->Done(&ptr)) {
741 ::uint32_t tag;
742 ptr = ::_pbi::ReadTag(ptr, &tag);
743 switch (tag >> 3) {
744 // optional uint32 num = 1;
745 case 1:
746 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
747 _Internal::set_has_num(&has_bits);
748 _impl_.num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
749 CHK_(ptr);
750 } else {
751 goto handle_unusual;
752 }
753 continue;
754 // optional uint32 play_cnt = 2;
755 case 2:
756 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
757 _Internal::set_has_play_cnt(&has_bits);
758 _impl_.play_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
759 CHK_(ptr);
760 } else {
761 goto handle_unusual;
762 }
763 continue;
764 // optional uint32 clk_rate = 3;
765 case 3:
766 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
767 _Internal::set_has_clk_rate(&has_bits);
768 _impl_.clk_rate_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
769 CHK_(ptr);
770 } else {
771 goto handle_unusual;
772 }
773 continue;
774 // optional uint64 bandwidth = 4;
775 case 4:
776 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
777 _Internal::set_has_bandwidth(&has_bits);
778 _impl_.bandwidth_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
779 CHK_(ptr);
780 } else {
781 goto handle_unusual;
782 }
783 continue;
784 default:
785 goto handle_unusual;
786 } // switch
787 handle_unusual:
788 if ((tag == 0) || ((tag & 7) == 4)) {
789 CHK_(ptr);
790 ctx->SetLastTag(tag);
791 goto message_done;
792 }
793 ptr = UnknownFieldParse(
794 tag,
795 _internal_metadata_.mutable_unknown_fields<std::string>(),
796 ptr, ctx);
797 CHK_(ptr != nullptr);
798 } // while
799 message_done:
800 _impl_._has_bits_.Or(has_bits);
801 return ptr;
802 failure:
803 ptr = nullptr;
804 goto message_done;
805 #undef CHK_
806 }
807
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const808 ::uint8_t* MdpCommitFtraceEvent::_InternalSerialize(
809 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
810 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCommitFtraceEvent)
811 ::uint32_t cached_has_bits = 0;
812 (void) cached_has_bits;
813
814 cached_has_bits = _impl_._has_bits_[0];
815 // optional uint32 num = 1;
816 if (cached_has_bits & 0x00000001u) {
817 target = stream->EnsureSpace(target);
818 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num(), target);
819 }
820
821 // optional uint32 play_cnt = 2;
822 if (cached_has_bits & 0x00000002u) {
823 target = stream->EnsureSpace(target);
824 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_play_cnt(), target);
825 }
826
827 // optional uint32 clk_rate = 3;
828 if (cached_has_bits & 0x00000008u) {
829 target = stream->EnsureSpace(target);
830 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_clk_rate(), target);
831 }
832
833 // optional uint64 bandwidth = 4;
834 if (cached_has_bits & 0x00000004u) {
835 target = stream->EnsureSpace(target);
836 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_bandwidth(), target);
837 }
838
839 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
840 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
841 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
842 }
843 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCommitFtraceEvent)
844 return target;
845 }
846
ByteSizeLong() const847 size_t MdpCommitFtraceEvent::ByteSizeLong() const {
848 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCommitFtraceEvent)
849 size_t total_size = 0;
850
851 ::uint32_t cached_has_bits = 0;
852 // Prevent compiler warnings about cached_has_bits being unused
853 (void) cached_has_bits;
854
855 cached_has_bits = _impl_._has_bits_[0];
856 if (cached_has_bits & 0x0000000fu) {
857 // optional uint32 num = 1;
858 if (cached_has_bits & 0x00000001u) {
859 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_num());
860 }
861
862 // optional uint32 play_cnt = 2;
863 if (cached_has_bits & 0x00000002u) {
864 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_play_cnt());
865 }
866
867 // optional uint64 bandwidth = 4;
868 if (cached_has_bits & 0x00000004u) {
869 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_bandwidth());
870 }
871
872 // optional uint32 clk_rate = 3;
873 if (cached_has_bits & 0x00000008u) {
874 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_clk_rate());
875 }
876
877 }
878 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
879 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
880 }
881 int cached_size = ::_pbi::ToCachedSize(total_size);
882 SetCachedSize(cached_size);
883 return total_size;
884 }
885
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)886 void MdpCommitFtraceEvent::CheckTypeAndMergeFrom(
887 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
888 MergeFrom(*::_pbi::DownCast<const MdpCommitFtraceEvent*>(
889 &from));
890 }
891
MergeFrom(const MdpCommitFtraceEvent & from)892 void MdpCommitFtraceEvent::MergeFrom(const MdpCommitFtraceEvent& from) {
893 MdpCommitFtraceEvent* const _this = this;
894 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCommitFtraceEvent)
895 GOOGLE_DCHECK_NE(&from, _this);
896 ::uint32_t cached_has_bits = 0;
897 (void) cached_has_bits;
898
899 cached_has_bits = from._impl_._has_bits_[0];
900 if (cached_has_bits & 0x0000000fu) {
901 if (cached_has_bits & 0x00000001u) {
902 _this->_impl_.num_ = from._impl_.num_;
903 }
904 if (cached_has_bits & 0x00000002u) {
905 _this->_impl_.play_cnt_ = from._impl_.play_cnt_;
906 }
907 if (cached_has_bits & 0x00000004u) {
908 _this->_impl_.bandwidth_ = from._impl_.bandwidth_;
909 }
910 if (cached_has_bits & 0x00000008u) {
911 _this->_impl_.clk_rate_ = from._impl_.clk_rate_;
912 }
913 _this->_impl_._has_bits_[0] |= cached_has_bits;
914 }
915 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
916 }
917
CopyFrom(const MdpCommitFtraceEvent & from)918 void MdpCommitFtraceEvent::CopyFrom(const MdpCommitFtraceEvent& from) {
919 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCommitFtraceEvent)
920 if (&from == this) return;
921 Clear();
922 MergeFrom(from);
923 }
924
IsInitialized() const925 bool MdpCommitFtraceEvent::IsInitialized() const {
926 return true;
927 }
928
InternalSwap(MdpCommitFtraceEvent * other)929 void MdpCommitFtraceEvent::InternalSwap(MdpCommitFtraceEvent* other) {
930 using std::swap;
931 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
932 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
933 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
934 PROTOBUF_FIELD_OFFSET(MdpCommitFtraceEvent, _impl_.clk_rate_)
935 + sizeof(MdpCommitFtraceEvent::_impl_.clk_rate_) // NOLINT
936 - PROTOBUF_FIELD_OFFSET(MdpCommitFtraceEvent, _impl_.num_)>(
937 reinterpret_cast<char*>(&_impl_.num_),
938 reinterpret_cast<char*>(&other->_impl_.num_));
939 }
940
GetTypeName() const941 std::string MdpCommitFtraceEvent::GetTypeName() const {
942 return "perfetto.protos.MdpCommitFtraceEvent";
943 }
944
945
946 // ===================================================================
947
948 class MdpPerfSetOtFtraceEvent::_Internal {
949 public:
950 using HasBits = decltype(std::declval<MdpPerfSetOtFtraceEvent>()._impl_._has_bits_);
set_has_pnum(HasBits * has_bits)951 static void set_has_pnum(HasBits* has_bits) {
952 (*has_bits)[0] |= 1u;
953 }
set_has_xin_id(HasBits * has_bits)954 static void set_has_xin_id(HasBits* has_bits) {
955 (*has_bits)[0] |= 2u;
956 }
set_has_rd_lim(HasBits * has_bits)957 static void set_has_rd_lim(HasBits* has_bits) {
958 (*has_bits)[0] |= 4u;
959 }
set_has_is_vbif_rt(HasBits * has_bits)960 static void set_has_is_vbif_rt(HasBits* has_bits) {
961 (*has_bits)[0] |= 8u;
962 }
963 };
964
MdpPerfSetOtFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)965 MdpPerfSetOtFtraceEvent::MdpPerfSetOtFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
966 bool is_message_owned)
967 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
968 SharedCtor(arena, is_message_owned);
969 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpPerfSetOtFtraceEvent)
970 }
MdpPerfSetOtFtraceEvent(const MdpPerfSetOtFtraceEvent & from)971 MdpPerfSetOtFtraceEvent::MdpPerfSetOtFtraceEvent(const MdpPerfSetOtFtraceEvent& from)
972 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
973 MdpPerfSetOtFtraceEvent* const _this = this; (void)_this;
974 new (&_impl_) Impl_{
975 decltype(_impl_._has_bits_){from._impl_._has_bits_}
976 , /*decltype(_impl_._cached_size_)*/{}
977 , decltype(_impl_.pnum_){}
978 , decltype(_impl_.xin_id_){}
979 , decltype(_impl_.rd_lim_){}
980 , decltype(_impl_.is_vbif_rt_){}};
981
982 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
983 ::memcpy(&_impl_.pnum_, &from._impl_.pnum_,
984 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_vbif_rt_) -
985 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.is_vbif_rt_));
986 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpPerfSetOtFtraceEvent)
987 }
988
SharedCtor(::_pb::Arena * arena,bool is_message_owned)989 inline void MdpPerfSetOtFtraceEvent::SharedCtor(
990 ::_pb::Arena* arena, bool is_message_owned) {
991 (void)arena;
992 (void)is_message_owned;
993 new (&_impl_) Impl_{
994 decltype(_impl_._has_bits_){}
995 , /*decltype(_impl_._cached_size_)*/{}
996 , decltype(_impl_.pnum_){0u}
997 , decltype(_impl_.xin_id_){0u}
998 , decltype(_impl_.rd_lim_){0u}
999 , decltype(_impl_.is_vbif_rt_){0u}
1000 };
1001 }
1002
~MdpPerfSetOtFtraceEvent()1003 MdpPerfSetOtFtraceEvent::~MdpPerfSetOtFtraceEvent() {
1004 // @@protoc_insertion_point(destructor:perfetto.protos.MdpPerfSetOtFtraceEvent)
1005 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1006 (void)arena;
1007 return;
1008 }
1009 SharedDtor();
1010 }
1011
SharedDtor()1012 inline void MdpPerfSetOtFtraceEvent::SharedDtor() {
1013 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1014 }
1015
SetCachedSize(int size) const1016 void MdpPerfSetOtFtraceEvent::SetCachedSize(int size) const {
1017 _impl_._cached_size_.Set(size);
1018 }
1019
Clear()1020 void MdpPerfSetOtFtraceEvent::Clear() {
1021 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpPerfSetOtFtraceEvent)
1022 ::uint32_t cached_has_bits = 0;
1023 // Prevent compiler warnings about cached_has_bits being unused
1024 (void) cached_has_bits;
1025
1026 cached_has_bits = _impl_._has_bits_[0];
1027 if (cached_has_bits & 0x0000000fu) {
1028 ::memset(&_impl_.pnum_, 0, static_cast<size_t>(
1029 reinterpret_cast<char*>(&_impl_.is_vbif_rt_) -
1030 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.is_vbif_rt_));
1031 }
1032 _impl_._has_bits_.Clear();
1033 _internal_metadata_.Clear<std::string>();
1034 }
1035
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1036 const char* MdpPerfSetOtFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1037 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1038 _Internal::HasBits has_bits{};
1039 while (!ctx->Done(&ptr)) {
1040 ::uint32_t tag;
1041 ptr = ::_pbi::ReadTag(ptr, &tag);
1042 switch (tag >> 3) {
1043 // optional uint32 pnum = 1;
1044 case 1:
1045 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1046 _Internal::set_has_pnum(&has_bits);
1047 _impl_.pnum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1048 CHK_(ptr);
1049 } else {
1050 goto handle_unusual;
1051 }
1052 continue;
1053 // optional uint32 xin_id = 2;
1054 case 2:
1055 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1056 _Internal::set_has_xin_id(&has_bits);
1057 _impl_.xin_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1058 CHK_(ptr);
1059 } else {
1060 goto handle_unusual;
1061 }
1062 continue;
1063 // optional uint32 rd_lim = 3;
1064 case 3:
1065 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1066 _Internal::set_has_rd_lim(&has_bits);
1067 _impl_.rd_lim_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1068 CHK_(ptr);
1069 } else {
1070 goto handle_unusual;
1071 }
1072 continue;
1073 // optional uint32 is_vbif_rt = 4;
1074 case 4:
1075 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1076 _Internal::set_has_is_vbif_rt(&has_bits);
1077 _impl_.is_vbif_rt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1078 CHK_(ptr);
1079 } else {
1080 goto handle_unusual;
1081 }
1082 continue;
1083 default:
1084 goto handle_unusual;
1085 } // switch
1086 handle_unusual:
1087 if ((tag == 0) || ((tag & 7) == 4)) {
1088 CHK_(ptr);
1089 ctx->SetLastTag(tag);
1090 goto message_done;
1091 }
1092 ptr = UnknownFieldParse(
1093 tag,
1094 _internal_metadata_.mutable_unknown_fields<std::string>(),
1095 ptr, ctx);
1096 CHK_(ptr != nullptr);
1097 } // while
1098 message_done:
1099 _impl_._has_bits_.Or(has_bits);
1100 return ptr;
1101 failure:
1102 ptr = nullptr;
1103 goto message_done;
1104 #undef CHK_
1105 }
1106
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1107 ::uint8_t* MdpPerfSetOtFtraceEvent::_InternalSerialize(
1108 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1109 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpPerfSetOtFtraceEvent)
1110 ::uint32_t cached_has_bits = 0;
1111 (void) cached_has_bits;
1112
1113 cached_has_bits = _impl_._has_bits_[0];
1114 // optional uint32 pnum = 1;
1115 if (cached_has_bits & 0x00000001u) {
1116 target = stream->EnsureSpace(target);
1117 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pnum(), target);
1118 }
1119
1120 // optional uint32 xin_id = 2;
1121 if (cached_has_bits & 0x00000002u) {
1122 target = stream->EnsureSpace(target);
1123 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_xin_id(), target);
1124 }
1125
1126 // optional uint32 rd_lim = 3;
1127 if (cached_has_bits & 0x00000004u) {
1128 target = stream->EnsureSpace(target);
1129 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_rd_lim(), target);
1130 }
1131
1132 // optional uint32 is_vbif_rt = 4;
1133 if (cached_has_bits & 0x00000008u) {
1134 target = stream->EnsureSpace(target);
1135 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_is_vbif_rt(), target);
1136 }
1137
1138 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1139 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1140 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1141 }
1142 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpPerfSetOtFtraceEvent)
1143 return target;
1144 }
1145
ByteSizeLong() const1146 size_t MdpPerfSetOtFtraceEvent::ByteSizeLong() const {
1147 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpPerfSetOtFtraceEvent)
1148 size_t total_size = 0;
1149
1150 ::uint32_t cached_has_bits = 0;
1151 // Prevent compiler warnings about cached_has_bits being unused
1152 (void) cached_has_bits;
1153
1154 cached_has_bits = _impl_._has_bits_[0];
1155 if (cached_has_bits & 0x0000000fu) {
1156 // optional uint32 pnum = 1;
1157 if (cached_has_bits & 0x00000001u) {
1158 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pnum());
1159 }
1160
1161 // optional uint32 xin_id = 2;
1162 if (cached_has_bits & 0x00000002u) {
1163 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_xin_id());
1164 }
1165
1166 // optional uint32 rd_lim = 3;
1167 if (cached_has_bits & 0x00000004u) {
1168 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rd_lim());
1169 }
1170
1171 // optional uint32 is_vbif_rt = 4;
1172 if (cached_has_bits & 0x00000008u) {
1173 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_is_vbif_rt());
1174 }
1175
1176 }
1177 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1178 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1179 }
1180 int cached_size = ::_pbi::ToCachedSize(total_size);
1181 SetCachedSize(cached_size);
1182 return total_size;
1183 }
1184
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1185 void MdpPerfSetOtFtraceEvent::CheckTypeAndMergeFrom(
1186 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1187 MergeFrom(*::_pbi::DownCast<const MdpPerfSetOtFtraceEvent*>(
1188 &from));
1189 }
1190
MergeFrom(const MdpPerfSetOtFtraceEvent & from)1191 void MdpPerfSetOtFtraceEvent::MergeFrom(const MdpPerfSetOtFtraceEvent& from) {
1192 MdpPerfSetOtFtraceEvent* const _this = this;
1193 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpPerfSetOtFtraceEvent)
1194 GOOGLE_DCHECK_NE(&from, _this);
1195 ::uint32_t cached_has_bits = 0;
1196 (void) cached_has_bits;
1197
1198 cached_has_bits = from._impl_._has_bits_[0];
1199 if (cached_has_bits & 0x0000000fu) {
1200 if (cached_has_bits & 0x00000001u) {
1201 _this->_impl_.pnum_ = from._impl_.pnum_;
1202 }
1203 if (cached_has_bits & 0x00000002u) {
1204 _this->_impl_.xin_id_ = from._impl_.xin_id_;
1205 }
1206 if (cached_has_bits & 0x00000004u) {
1207 _this->_impl_.rd_lim_ = from._impl_.rd_lim_;
1208 }
1209 if (cached_has_bits & 0x00000008u) {
1210 _this->_impl_.is_vbif_rt_ = from._impl_.is_vbif_rt_;
1211 }
1212 _this->_impl_._has_bits_[0] |= cached_has_bits;
1213 }
1214 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1215 }
1216
CopyFrom(const MdpPerfSetOtFtraceEvent & from)1217 void MdpPerfSetOtFtraceEvent::CopyFrom(const MdpPerfSetOtFtraceEvent& from) {
1218 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpPerfSetOtFtraceEvent)
1219 if (&from == this) return;
1220 Clear();
1221 MergeFrom(from);
1222 }
1223
IsInitialized() const1224 bool MdpPerfSetOtFtraceEvent::IsInitialized() const {
1225 return true;
1226 }
1227
InternalSwap(MdpPerfSetOtFtraceEvent * other)1228 void MdpPerfSetOtFtraceEvent::InternalSwap(MdpPerfSetOtFtraceEvent* other) {
1229 using std::swap;
1230 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1231 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1232 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1233 PROTOBUF_FIELD_OFFSET(MdpPerfSetOtFtraceEvent, _impl_.is_vbif_rt_)
1234 + sizeof(MdpPerfSetOtFtraceEvent::_impl_.is_vbif_rt_) // NOLINT
1235 - PROTOBUF_FIELD_OFFSET(MdpPerfSetOtFtraceEvent, _impl_.pnum_)>(
1236 reinterpret_cast<char*>(&_impl_.pnum_),
1237 reinterpret_cast<char*>(&other->_impl_.pnum_));
1238 }
1239
GetTypeName() const1240 std::string MdpPerfSetOtFtraceEvent::GetTypeName() const {
1241 return "perfetto.protos.MdpPerfSetOtFtraceEvent";
1242 }
1243
1244
1245 // ===================================================================
1246
1247 class MdpSsppChangeFtraceEvent::_Internal {
1248 public:
1249 using HasBits = decltype(std::declval<MdpSsppChangeFtraceEvent>()._impl_._has_bits_);
set_has_num(HasBits * has_bits)1250 static void set_has_num(HasBits* has_bits) {
1251 (*has_bits)[0] |= 1u;
1252 }
set_has_play_cnt(HasBits * has_bits)1253 static void set_has_play_cnt(HasBits* has_bits) {
1254 (*has_bits)[0] |= 2u;
1255 }
set_has_mixer(HasBits * has_bits)1256 static void set_has_mixer(HasBits* has_bits) {
1257 (*has_bits)[0] |= 4u;
1258 }
set_has_stage(HasBits * has_bits)1259 static void set_has_stage(HasBits* has_bits) {
1260 (*has_bits)[0] |= 8u;
1261 }
set_has_flags(HasBits * has_bits)1262 static void set_has_flags(HasBits* has_bits) {
1263 (*has_bits)[0] |= 16u;
1264 }
set_has_format(HasBits * has_bits)1265 static void set_has_format(HasBits* has_bits) {
1266 (*has_bits)[0] |= 32u;
1267 }
set_has_img_w(HasBits * has_bits)1268 static void set_has_img_w(HasBits* has_bits) {
1269 (*has_bits)[0] |= 64u;
1270 }
set_has_img_h(HasBits * has_bits)1271 static void set_has_img_h(HasBits* has_bits) {
1272 (*has_bits)[0] |= 128u;
1273 }
set_has_src_x(HasBits * has_bits)1274 static void set_has_src_x(HasBits* has_bits) {
1275 (*has_bits)[0] |= 256u;
1276 }
set_has_src_y(HasBits * has_bits)1277 static void set_has_src_y(HasBits* has_bits) {
1278 (*has_bits)[0] |= 512u;
1279 }
set_has_src_w(HasBits * has_bits)1280 static void set_has_src_w(HasBits* has_bits) {
1281 (*has_bits)[0] |= 1024u;
1282 }
set_has_src_h(HasBits * has_bits)1283 static void set_has_src_h(HasBits* has_bits) {
1284 (*has_bits)[0] |= 2048u;
1285 }
set_has_dst_x(HasBits * has_bits)1286 static void set_has_dst_x(HasBits* has_bits) {
1287 (*has_bits)[0] |= 4096u;
1288 }
set_has_dst_y(HasBits * has_bits)1289 static void set_has_dst_y(HasBits* has_bits) {
1290 (*has_bits)[0] |= 8192u;
1291 }
set_has_dst_w(HasBits * has_bits)1292 static void set_has_dst_w(HasBits* has_bits) {
1293 (*has_bits)[0] |= 16384u;
1294 }
set_has_dst_h(HasBits * has_bits)1295 static void set_has_dst_h(HasBits* has_bits) {
1296 (*has_bits)[0] |= 32768u;
1297 }
1298 };
1299
MdpSsppChangeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1300 MdpSsppChangeFtraceEvent::MdpSsppChangeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1301 bool is_message_owned)
1302 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1303 SharedCtor(arena, is_message_owned);
1304 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpSsppChangeFtraceEvent)
1305 }
MdpSsppChangeFtraceEvent(const MdpSsppChangeFtraceEvent & from)1306 MdpSsppChangeFtraceEvent::MdpSsppChangeFtraceEvent(const MdpSsppChangeFtraceEvent& from)
1307 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1308 MdpSsppChangeFtraceEvent* const _this = this; (void)_this;
1309 new (&_impl_) Impl_{
1310 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1311 , /*decltype(_impl_._cached_size_)*/{}
1312 , decltype(_impl_.num_){}
1313 , decltype(_impl_.play_cnt_){}
1314 , decltype(_impl_.mixer_){}
1315 , decltype(_impl_.stage_){}
1316 , decltype(_impl_.flags_){}
1317 , decltype(_impl_.format_){}
1318 , decltype(_impl_.img_w_){}
1319 , decltype(_impl_.img_h_){}
1320 , decltype(_impl_.src_x_){}
1321 , decltype(_impl_.src_y_){}
1322 , decltype(_impl_.src_w_){}
1323 , decltype(_impl_.src_h_){}
1324 , decltype(_impl_.dst_x_){}
1325 , decltype(_impl_.dst_y_){}
1326 , decltype(_impl_.dst_w_){}
1327 , decltype(_impl_.dst_h_){}};
1328
1329 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1330 ::memcpy(&_impl_.num_, &from._impl_.num_,
1331 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dst_h_) -
1332 reinterpret_cast<char*>(&_impl_.num_)) + sizeof(_impl_.dst_h_));
1333 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpSsppChangeFtraceEvent)
1334 }
1335
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1336 inline void MdpSsppChangeFtraceEvent::SharedCtor(
1337 ::_pb::Arena* arena, bool is_message_owned) {
1338 (void)arena;
1339 (void)is_message_owned;
1340 new (&_impl_) Impl_{
1341 decltype(_impl_._has_bits_){}
1342 , /*decltype(_impl_._cached_size_)*/{}
1343 , decltype(_impl_.num_){0u}
1344 , decltype(_impl_.play_cnt_){0u}
1345 , decltype(_impl_.mixer_){0u}
1346 , decltype(_impl_.stage_){0u}
1347 , decltype(_impl_.flags_){0u}
1348 , decltype(_impl_.format_){0u}
1349 , decltype(_impl_.img_w_){0u}
1350 , decltype(_impl_.img_h_){0u}
1351 , decltype(_impl_.src_x_){0u}
1352 , decltype(_impl_.src_y_){0u}
1353 , decltype(_impl_.src_w_){0u}
1354 , decltype(_impl_.src_h_){0u}
1355 , decltype(_impl_.dst_x_){0u}
1356 , decltype(_impl_.dst_y_){0u}
1357 , decltype(_impl_.dst_w_){0u}
1358 , decltype(_impl_.dst_h_){0u}
1359 };
1360 }
1361
~MdpSsppChangeFtraceEvent()1362 MdpSsppChangeFtraceEvent::~MdpSsppChangeFtraceEvent() {
1363 // @@protoc_insertion_point(destructor:perfetto.protos.MdpSsppChangeFtraceEvent)
1364 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1365 (void)arena;
1366 return;
1367 }
1368 SharedDtor();
1369 }
1370
SharedDtor()1371 inline void MdpSsppChangeFtraceEvent::SharedDtor() {
1372 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1373 }
1374
SetCachedSize(int size) const1375 void MdpSsppChangeFtraceEvent::SetCachedSize(int size) const {
1376 _impl_._cached_size_.Set(size);
1377 }
1378
Clear()1379 void MdpSsppChangeFtraceEvent::Clear() {
1380 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpSsppChangeFtraceEvent)
1381 ::uint32_t cached_has_bits = 0;
1382 // Prevent compiler warnings about cached_has_bits being unused
1383 (void) cached_has_bits;
1384
1385 cached_has_bits = _impl_._has_bits_[0];
1386 if (cached_has_bits & 0x000000ffu) {
1387 ::memset(&_impl_.num_, 0, static_cast<size_t>(
1388 reinterpret_cast<char*>(&_impl_.img_h_) -
1389 reinterpret_cast<char*>(&_impl_.num_)) + sizeof(_impl_.img_h_));
1390 }
1391 if (cached_has_bits & 0x0000ff00u) {
1392 ::memset(&_impl_.src_x_, 0, static_cast<size_t>(
1393 reinterpret_cast<char*>(&_impl_.dst_h_) -
1394 reinterpret_cast<char*>(&_impl_.src_x_)) + sizeof(_impl_.dst_h_));
1395 }
1396 _impl_._has_bits_.Clear();
1397 _internal_metadata_.Clear<std::string>();
1398 }
1399
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1400 const char* MdpSsppChangeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1401 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1402 _Internal::HasBits has_bits{};
1403 while (!ctx->Done(&ptr)) {
1404 ::uint32_t tag;
1405 ptr = ::_pbi::ReadTag(ptr, &tag);
1406 switch (tag >> 3) {
1407 // optional uint32 num = 1;
1408 case 1:
1409 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1410 _Internal::set_has_num(&has_bits);
1411 _impl_.num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1412 CHK_(ptr);
1413 } else {
1414 goto handle_unusual;
1415 }
1416 continue;
1417 // optional uint32 play_cnt = 2;
1418 case 2:
1419 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1420 _Internal::set_has_play_cnt(&has_bits);
1421 _impl_.play_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1422 CHK_(ptr);
1423 } else {
1424 goto handle_unusual;
1425 }
1426 continue;
1427 // optional uint32 mixer = 3;
1428 case 3:
1429 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1430 _Internal::set_has_mixer(&has_bits);
1431 _impl_.mixer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1432 CHK_(ptr);
1433 } else {
1434 goto handle_unusual;
1435 }
1436 continue;
1437 // optional uint32 stage = 4;
1438 case 4:
1439 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1440 _Internal::set_has_stage(&has_bits);
1441 _impl_.stage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1442 CHK_(ptr);
1443 } else {
1444 goto handle_unusual;
1445 }
1446 continue;
1447 // optional uint32 flags = 5;
1448 case 5:
1449 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1450 _Internal::set_has_flags(&has_bits);
1451 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1452 CHK_(ptr);
1453 } else {
1454 goto handle_unusual;
1455 }
1456 continue;
1457 // optional uint32 format = 6;
1458 case 6:
1459 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1460 _Internal::set_has_format(&has_bits);
1461 _impl_.format_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1462 CHK_(ptr);
1463 } else {
1464 goto handle_unusual;
1465 }
1466 continue;
1467 // optional uint32 img_w = 7;
1468 case 7:
1469 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1470 _Internal::set_has_img_w(&has_bits);
1471 _impl_.img_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1472 CHK_(ptr);
1473 } else {
1474 goto handle_unusual;
1475 }
1476 continue;
1477 // optional uint32 img_h = 8;
1478 case 8:
1479 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1480 _Internal::set_has_img_h(&has_bits);
1481 _impl_.img_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1482 CHK_(ptr);
1483 } else {
1484 goto handle_unusual;
1485 }
1486 continue;
1487 // optional uint32 src_x = 9;
1488 case 9:
1489 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1490 _Internal::set_has_src_x(&has_bits);
1491 _impl_.src_x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1492 CHK_(ptr);
1493 } else {
1494 goto handle_unusual;
1495 }
1496 continue;
1497 // optional uint32 src_y = 10;
1498 case 10:
1499 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
1500 _Internal::set_has_src_y(&has_bits);
1501 _impl_.src_y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1502 CHK_(ptr);
1503 } else {
1504 goto handle_unusual;
1505 }
1506 continue;
1507 // optional uint32 src_w = 11;
1508 case 11:
1509 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1510 _Internal::set_has_src_w(&has_bits);
1511 _impl_.src_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1512 CHK_(ptr);
1513 } else {
1514 goto handle_unusual;
1515 }
1516 continue;
1517 // optional uint32 src_h = 12;
1518 case 12:
1519 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
1520 _Internal::set_has_src_h(&has_bits);
1521 _impl_.src_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1522 CHK_(ptr);
1523 } else {
1524 goto handle_unusual;
1525 }
1526 continue;
1527 // optional uint32 dst_x = 13;
1528 case 13:
1529 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
1530 _Internal::set_has_dst_x(&has_bits);
1531 _impl_.dst_x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1532 CHK_(ptr);
1533 } else {
1534 goto handle_unusual;
1535 }
1536 continue;
1537 // optional uint32 dst_y = 14;
1538 case 14:
1539 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
1540 _Internal::set_has_dst_y(&has_bits);
1541 _impl_.dst_y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1542 CHK_(ptr);
1543 } else {
1544 goto handle_unusual;
1545 }
1546 continue;
1547 // optional uint32 dst_w = 15;
1548 case 15:
1549 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
1550 _Internal::set_has_dst_w(&has_bits);
1551 _impl_.dst_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1552 CHK_(ptr);
1553 } else {
1554 goto handle_unusual;
1555 }
1556 continue;
1557 // optional uint32 dst_h = 16;
1558 case 16:
1559 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
1560 _Internal::set_has_dst_h(&has_bits);
1561 _impl_.dst_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1562 CHK_(ptr);
1563 } else {
1564 goto handle_unusual;
1565 }
1566 continue;
1567 default:
1568 goto handle_unusual;
1569 } // switch
1570 handle_unusual:
1571 if ((tag == 0) || ((tag & 7) == 4)) {
1572 CHK_(ptr);
1573 ctx->SetLastTag(tag);
1574 goto message_done;
1575 }
1576 ptr = UnknownFieldParse(
1577 tag,
1578 _internal_metadata_.mutable_unknown_fields<std::string>(),
1579 ptr, ctx);
1580 CHK_(ptr != nullptr);
1581 } // while
1582 message_done:
1583 _impl_._has_bits_.Or(has_bits);
1584 return ptr;
1585 failure:
1586 ptr = nullptr;
1587 goto message_done;
1588 #undef CHK_
1589 }
1590
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1591 ::uint8_t* MdpSsppChangeFtraceEvent::_InternalSerialize(
1592 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1593 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpSsppChangeFtraceEvent)
1594 ::uint32_t cached_has_bits = 0;
1595 (void) cached_has_bits;
1596
1597 cached_has_bits = _impl_._has_bits_[0];
1598 // optional uint32 num = 1;
1599 if (cached_has_bits & 0x00000001u) {
1600 target = stream->EnsureSpace(target);
1601 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num(), target);
1602 }
1603
1604 // optional uint32 play_cnt = 2;
1605 if (cached_has_bits & 0x00000002u) {
1606 target = stream->EnsureSpace(target);
1607 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_play_cnt(), target);
1608 }
1609
1610 // optional uint32 mixer = 3;
1611 if (cached_has_bits & 0x00000004u) {
1612 target = stream->EnsureSpace(target);
1613 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_mixer(), target);
1614 }
1615
1616 // optional uint32 stage = 4;
1617 if (cached_has_bits & 0x00000008u) {
1618 target = stream->EnsureSpace(target);
1619 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_stage(), target);
1620 }
1621
1622 // optional uint32 flags = 5;
1623 if (cached_has_bits & 0x00000010u) {
1624 target = stream->EnsureSpace(target);
1625 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_flags(), target);
1626 }
1627
1628 // optional uint32 format = 6;
1629 if (cached_has_bits & 0x00000020u) {
1630 target = stream->EnsureSpace(target);
1631 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_format(), target);
1632 }
1633
1634 // optional uint32 img_w = 7;
1635 if (cached_has_bits & 0x00000040u) {
1636 target = stream->EnsureSpace(target);
1637 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_img_w(), target);
1638 }
1639
1640 // optional uint32 img_h = 8;
1641 if (cached_has_bits & 0x00000080u) {
1642 target = stream->EnsureSpace(target);
1643 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_img_h(), target);
1644 }
1645
1646 // optional uint32 src_x = 9;
1647 if (cached_has_bits & 0x00000100u) {
1648 target = stream->EnsureSpace(target);
1649 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_src_x(), target);
1650 }
1651
1652 // optional uint32 src_y = 10;
1653 if (cached_has_bits & 0x00000200u) {
1654 target = stream->EnsureSpace(target);
1655 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_src_y(), target);
1656 }
1657
1658 // optional uint32 src_w = 11;
1659 if (cached_has_bits & 0x00000400u) {
1660 target = stream->EnsureSpace(target);
1661 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_src_w(), target);
1662 }
1663
1664 // optional uint32 src_h = 12;
1665 if (cached_has_bits & 0x00000800u) {
1666 target = stream->EnsureSpace(target);
1667 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(12, this->_internal_src_h(), target);
1668 }
1669
1670 // optional uint32 dst_x = 13;
1671 if (cached_has_bits & 0x00001000u) {
1672 target = stream->EnsureSpace(target);
1673 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(13, this->_internal_dst_x(), target);
1674 }
1675
1676 // optional uint32 dst_y = 14;
1677 if (cached_has_bits & 0x00002000u) {
1678 target = stream->EnsureSpace(target);
1679 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(14, this->_internal_dst_y(), target);
1680 }
1681
1682 // optional uint32 dst_w = 15;
1683 if (cached_has_bits & 0x00004000u) {
1684 target = stream->EnsureSpace(target);
1685 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(15, this->_internal_dst_w(), target);
1686 }
1687
1688 // optional uint32 dst_h = 16;
1689 if (cached_has_bits & 0x00008000u) {
1690 target = stream->EnsureSpace(target);
1691 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_dst_h(), target);
1692 }
1693
1694 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1695 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1696 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1697 }
1698 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpSsppChangeFtraceEvent)
1699 return target;
1700 }
1701
ByteSizeLong() const1702 size_t MdpSsppChangeFtraceEvent::ByteSizeLong() const {
1703 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpSsppChangeFtraceEvent)
1704 size_t total_size = 0;
1705
1706 ::uint32_t cached_has_bits = 0;
1707 // Prevent compiler warnings about cached_has_bits being unused
1708 (void) cached_has_bits;
1709
1710 cached_has_bits = _impl_._has_bits_[0];
1711 if (cached_has_bits & 0x000000ffu) {
1712 // optional uint32 num = 1;
1713 if (cached_has_bits & 0x00000001u) {
1714 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_num());
1715 }
1716
1717 // optional uint32 play_cnt = 2;
1718 if (cached_has_bits & 0x00000002u) {
1719 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_play_cnt());
1720 }
1721
1722 // optional uint32 mixer = 3;
1723 if (cached_has_bits & 0x00000004u) {
1724 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mixer());
1725 }
1726
1727 // optional uint32 stage = 4;
1728 if (cached_has_bits & 0x00000008u) {
1729 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_stage());
1730 }
1731
1732 // optional uint32 flags = 5;
1733 if (cached_has_bits & 0x00000010u) {
1734 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
1735 }
1736
1737 // optional uint32 format = 6;
1738 if (cached_has_bits & 0x00000020u) {
1739 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_format());
1740 }
1741
1742 // optional uint32 img_w = 7;
1743 if (cached_has_bits & 0x00000040u) {
1744 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_img_w());
1745 }
1746
1747 // optional uint32 img_h = 8;
1748 if (cached_has_bits & 0x00000080u) {
1749 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_img_h());
1750 }
1751
1752 }
1753 if (cached_has_bits & 0x0000ff00u) {
1754 // optional uint32 src_x = 9;
1755 if (cached_has_bits & 0x00000100u) {
1756 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_x());
1757 }
1758
1759 // optional uint32 src_y = 10;
1760 if (cached_has_bits & 0x00000200u) {
1761 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_y());
1762 }
1763
1764 // optional uint32 src_w = 11;
1765 if (cached_has_bits & 0x00000400u) {
1766 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_w());
1767 }
1768
1769 // optional uint32 src_h = 12;
1770 if (cached_has_bits & 0x00000800u) {
1771 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_h());
1772 }
1773
1774 // optional uint32 dst_x = 13;
1775 if (cached_has_bits & 0x00001000u) {
1776 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dst_x());
1777 }
1778
1779 // optional uint32 dst_y = 14;
1780 if (cached_has_bits & 0x00002000u) {
1781 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dst_y());
1782 }
1783
1784 // optional uint32 dst_w = 15;
1785 if (cached_has_bits & 0x00004000u) {
1786 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dst_w());
1787 }
1788
1789 // optional uint32 dst_h = 16;
1790 if (cached_has_bits & 0x00008000u) {
1791 total_size += 2 +
1792 ::_pbi::WireFormatLite::UInt32Size(
1793 this->_internal_dst_h());
1794 }
1795
1796 }
1797 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1798 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1799 }
1800 int cached_size = ::_pbi::ToCachedSize(total_size);
1801 SetCachedSize(cached_size);
1802 return total_size;
1803 }
1804
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1805 void MdpSsppChangeFtraceEvent::CheckTypeAndMergeFrom(
1806 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1807 MergeFrom(*::_pbi::DownCast<const MdpSsppChangeFtraceEvent*>(
1808 &from));
1809 }
1810
MergeFrom(const MdpSsppChangeFtraceEvent & from)1811 void MdpSsppChangeFtraceEvent::MergeFrom(const MdpSsppChangeFtraceEvent& from) {
1812 MdpSsppChangeFtraceEvent* const _this = this;
1813 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpSsppChangeFtraceEvent)
1814 GOOGLE_DCHECK_NE(&from, _this);
1815 ::uint32_t cached_has_bits = 0;
1816 (void) cached_has_bits;
1817
1818 cached_has_bits = from._impl_._has_bits_[0];
1819 if (cached_has_bits & 0x000000ffu) {
1820 if (cached_has_bits & 0x00000001u) {
1821 _this->_impl_.num_ = from._impl_.num_;
1822 }
1823 if (cached_has_bits & 0x00000002u) {
1824 _this->_impl_.play_cnt_ = from._impl_.play_cnt_;
1825 }
1826 if (cached_has_bits & 0x00000004u) {
1827 _this->_impl_.mixer_ = from._impl_.mixer_;
1828 }
1829 if (cached_has_bits & 0x00000008u) {
1830 _this->_impl_.stage_ = from._impl_.stage_;
1831 }
1832 if (cached_has_bits & 0x00000010u) {
1833 _this->_impl_.flags_ = from._impl_.flags_;
1834 }
1835 if (cached_has_bits & 0x00000020u) {
1836 _this->_impl_.format_ = from._impl_.format_;
1837 }
1838 if (cached_has_bits & 0x00000040u) {
1839 _this->_impl_.img_w_ = from._impl_.img_w_;
1840 }
1841 if (cached_has_bits & 0x00000080u) {
1842 _this->_impl_.img_h_ = from._impl_.img_h_;
1843 }
1844 _this->_impl_._has_bits_[0] |= cached_has_bits;
1845 }
1846 if (cached_has_bits & 0x0000ff00u) {
1847 if (cached_has_bits & 0x00000100u) {
1848 _this->_impl_.src_x_ = from._impl_.src_x_;
1849 }
1850 if (cached_has_bits & 0x00000200u) {
1851 _this->_impl_.src_y_ = from._impl_.src_y_;
1852 }
1853 if (cached_has_bits & 0x00000400u) {
1854 _this->_impl_.src_w_ = from._impl_.src_w_;
1855 }
1856 if (cached_has_bits & 0x00000800u) {
1857 _this->_impl_.src_h_ = from._impl_.src_h_;
1858 }
1859 if (cached_has_bits & 0x00001000u) {
1860 _this->_impl_.dst_x_ = from._impl_.dst_x_;
1861 }
1862 if (cached_has_bits & 0x00002000u) {
1863 _this->_impl_.dst_y_ = from._impl_.dst_y_;
1864 }
1865 if (cached_has_bits & 0x00004000u) {
1866 _this->_impl_.dst_w_ = from._impl_.dst_w_;
1867 }
1868 if (cached_has_bits & 0x00008000u) {
1869 _this->_impl_.dst_h_ = from._impl_.dst_h_;
1870 }
1871 _this->_impl_._has_bits_[0] |= cached_has_bits;
1872 }
1873 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1874 }
1875
CopyFrom(const MdpSsppChangeFtraceEvent & from)1876 void MdpSsppChangeFtraceEvent::CopyFrom(const MdpSsppChangeFtraceEvent& from) {
1877 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpSsppChangeFtraceEvent)
1878 if (&from == this) return;
1879 Clear();
1880 MergeFrom(from);
1881 }
1882
IsInitialized() const1883 bool MdpSsppChangeFtraceEvent::IsInitialized() const {
1884 return true;
1885 }
1886
InternalSwap(MdpSsppChangeFtraceEvent * other)1887 void MdpSsppChangeFtraceEvent::InternalSwap(MdpSsppChangeFtraceEvent* other) {
1888 using std::swap;
1889 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1890 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1891 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1892 PROTOBUF_FIELD_OFFSET(MdpSsppChangeFtraceEvent, _impl_.dst_h_)
1893 + sizeof(MdpSsppChangeFtraceEvent::_impl_.dst_h_) // NOLINT
1894 - PROTOBUF_FIELD_OFFSET(MdpSsppChangeFtraceEvent, _impl_.num_)>(
1895 reinterpret_cast<char*>(&_impl_.num_),
1896 reinterpret_cast<char*>(&other->_impl_.num_));
1897 }
1898
GetTypeName() const1899 std::string MdpSsppChangeFtraceEvent::GetTypeName() const {
1900 return "perfetto.protos.MdpSsppChangeFtraceEvent";
1901 }
1902
1903
1904 // ===================================================================
1905
1906 class TracingMarkWriteFtraceEvent::_Internal {
1907 public:
1908 using HasBits = decltype(std::declval<TracingMarkWriteFtraceEvent>()._impl_._has_bits_);
set_has_pid(HasBits * has_bits)1909 static void set_has_pid(HasBits* has_bits) {
1910 (*has_bits)[0] |= 2u;
1911 }
set_has_trace_name(HasBits * has_bits)1912 static void set_has_trace_name(HasBits* has_bits) {
1913 (*has_bits)[0] |= 1u;
1914 }
set_has_trace_begin(HasBits * has_bits)1915 static void set_has_trace_begin(HasBits* has_bits) {
1916 (*has_bits)[0] |= 4u;
1917 }
1918 };
1919
TracingMarkWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1920 TracingMarkWriteFtraceEvent::TracingMarkWriteFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1921 bool is_message_owned)
1922 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1923 SharedCtor(arena, is_message_owned);
1924 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TracingMarkWriteFtraceEvent)
1925 }
TracingMarkWriteFtraceEvent(const TracingMarkWriteFtraceEvent & from)1926 TracingMarkWriteFtraceEvent::TracingMarkWriteFtraceEvent(const TracingMarkWriteFtraceEvent& from)
1927 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1928 TracingMarkWriteFtraceEvent* const _this = this; (void)_this;
1929 new (&_impl_) Impl_{
1930 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1931 , /*decltype(_impl_._cached_size_)*/{}
1932 , decltype(_impl_.trace_name_){}
1933 , decltype(_impl_.pid_){}
1934 , decltype(_impl_.trace_begin_){}};
1935
1936 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1937 _impl_.trace_name_.InitDefault();
1938 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1939 _impl_.trace_name_.Set("", GetArenaForAllocation());
1940 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1941 if (from._internal_has_trace_name()) {
1942 _this->_impl_.trace_name_.Set(from._internal_trace_name(),
1943 _this->GetArenaForAllocation());
1944 }
1945 ::memcpy(&_impl_.pid_, &from._impl_.pid_,
1946 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.trace_begin_) -
1947 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.trace_begin_));
1948 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TracingMarkWriteFtraceEvent)
1949 }
1950
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1951 inline void TracingMarkWriteFtraceEvent::SharedCtor(
1952 ::_pb::Arena* arena, bool is_message_owned) {
1953 (void)arena;
1954 (void)is_message_owned;
1955 new (&_impl_) Impl_{
1956 decltype(_impl_._has_bits_){}
1957 , /*decltype(_impl_._cached_size_)*/{}
1958 , decltype(_impl_.trace_name_){}
1959 , decltype(_impl_.pid_){0}
1960 , decltype(_impl_.trace_begin_){0u}
1961 };
1962 _impl_.trace_name_.InitDefault();
1963 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1964 _impl_.trace_name_.Set("", GetArenaForAllocation());
1965 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1966 }
1967
~TracingMarkWriteFtraceEvent()1968 TracingMarkWriteFtraceEvent::~TracingMarkWriteFtraceEvent() {
1969 // @@protoc_insertion_point(destructor:perfetto.protos.TracingMarkWriteFtraceEvent)
1970 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1971 (void)arena;
1972 return;
1973 }
1974 SharedDtor();
1975 }
1976
SharedDtor()1977 inline void TracingMarkWriteFtraceEvent::SharedDtor() {
1978 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1979 _impl_.trace_name_.Destroy();
1980 }
1981
SetCachedSize(int size) const1982 void TracingMarkWriteFtraceEvent::SetCachedSize(int size) const {
1983 _impl_._cached_size_.Set(size);
1984 }
1985
Clear()1986 void TracingMarkWriteFtraceEvent::Clear() {
1987 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TracingMarkWriteFtraceEvent)
1988 ::uint32_t cached_has_bits = 0;
1989 // Prevent compiler warnings about cached_has_bits being unused
1990 (void) cached_has_bits;
1991
1992 cached_has_bits = _impl_._has_bits_[0];
1993 if (cached_has_bits & 0x00000001u) {
1994 _impl_.trace_name_.ClearNonDefaultToEmpty();
1995 }
1996 if (cached_has_bits & 0x00000006u) {
1997 ::memset(&_impl_.pid_, 0, static_cast<size_t>(
1998 reinterpret_cast<char*>(&_impl_.trace_begin_) -
1999 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.trace_begin_));
2000 }
2001 _impl_._has_bits_.Clear();
2002 _internal_metadata_.Clear<std::string>();
2003 }
2004
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2005 const char* TracingMarkWriteFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2006 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2007 _Internal::HasBits has_bits{};
2008 while (!ctx->Done(&ptr)) {
2009 ::uint32_t tag;
2010 ptr = ::_pbi::ReadTag(ptr, &tag);
2011 switch (tag >> 3) {
2012 // optional int32 pid = 1;
2013 case 1:
2014 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2015 _Internal::set_has_pid(&has_bits);
2016 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2017 CHK_(ptr);
2018 } else {
2019 goto handle_unusual;
2020 }
2021 continue;
2022 // optional string trace_name = 2;
2023 case 2:
2024 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
2025 auto str = _internal_mutable_trace_name();
2026 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2027 CHK_(ptr);
2028 } else {
2029 goto handle_unusual;
2030 }
2031 continue;
2032 // optional uint32 trace_begin = 3;
2033 case 3:
2034 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2035 _Internal::set_has_trace_begin(&has_bits);
2036 _impl_.trace_begin_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2037 CHK_(ptr);
2038 } else {
2039 goto handle_unusual;
2040 }
2041 continue;
2042 default:
2043 goto handle_unusual;
2044 } // switch
2045 handle_unusual:
2046 if ((tag == 0) || ((tag & 7) == 4)) {
2047 CHK_(ptr);
2048 ctx->SetLastTag(tag);
2049 goto message_done;
2050 }
2051 ptr = UnknownFieldParse(
2052 tag,
2053 _internal_metadata_.mutable_unknown_fields<std::string>(),
2054 ptr, ctx);
2055 CHK_(ptr != nullptr);
2056 } // while
2057 message_done:
2058 _impl_._has_bits_.Or(has_bits);
2059 return ptr;
2060 failure:
2061 ptr = nullptr;
2062 goto message_done;
2063 #undef CHK_
2064 }
2065
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2066 ::uint8_t* TracingMarkWriteFtraceEvent::_InternalSerialize(
2067 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2068 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TracingMarkWriteFtraceEvent)
2069 ::uint32_t cached_has_bits = 0;
2070 (void) cached_has_bits;
2071
2072 cached_has_bits = _impl_._has_bits_[0];
2073 // optional int32 pid = 1;
2074 if (cached_has_bits & 0x00000002u) {
2075 target = stream->EnsureSpace(target);
2076 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_pid(), target);
2077 }
2078
2079 // optional string trace_name = 2;
2080 if (cached_has_bits & 0x00000001u) {
2081 target = stream->WriteStringMaybeAliased(
2082 2, this->_internal_trace_name(), target);
2083 }
2084
2085 // optional uint32 trace_begin = 3;
2086 if (cached_has_bits & 0x00000004u) {
2087 target = stream->EnsureSpace(target);
2088 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_trace_begin(), target);
2089 }
2090
2091 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2092 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2093 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2094 }
2095 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TracingMarkWriteFtraceEvent)
2096 return target;
2097 }
2098
ByteSizeLong() const2099 size_t TracingMarkWriteFtraceEvent::ByteSizeLong() const {
2100 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TracingMarkWriteFtraceEvent)
2101 size_t total_size = 0;
2102
2103 ::uint32_t cached_has_bits = 0;
2104 // Prevent compiler warnings about cached_has_bits being unused
2105 (void) cached_has_bits;
2106
2107 cached_has_bits = _impl_._has_bits_[0];
2108 if (cached_has_bits & 0x00000007u) {
2109 // optional string trace_name = 2;
2110 if (cached_has_bits & 0x00000001u) {
2111 total_size += 1 +
2112 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2113 this->_internal_trace_name());
2114 }
2115
2116 // optional int32 pid = 1;
2117 if (cached_has_bits & 0x00000002u) {
2118 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
2119 }
2120
2121 // optional uint32 trace_begin = 3;
2122 if (cached_has_bits & 0x00000004u) {
2123 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_trace_begin());
2124 }
2125
2126 }
2127 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2128 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2129 }
2130 int cached_size = ::_pbi::ToCachedSize(total_size);
2131 SetCachedSize(cached_size);
2132 return total_size;
2133 }
2134
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2135 void TracingMarkWriteFtraceEvent::CheckTypeAndMergeFrom(
2136 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2137 MergeFrom(*::_pbi::DownCast<const TracingMarkWriteFtraceEvent*>(
2138 &from));
2139 }
2140
MergeFrom(const TracingMarkWriteFtraceEvent & from)2141 void TracingMarkWriteFtraceEvent::MergeFrom(const TracingMarkWriteFtraceEvent& from) {
2142 TracingMarkWriteFtraceEvent* const _this = this;
2143 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TracingMarkWriteFtraceEvent)
2144 GOOGLE_DCHECK_NE(&from, _this);
2145 ::uint32_t cached_has_bits = 0;
2146 (void) cached_has_bits;
2147
2148 cached_has_bits = from._impl_._has_bits_[0];
2149 if (cached_has_bits & 0x00000007u) {
2150 if (cached_has_bits & 0x00000001u) {
2151 _this->_internal_set_trace_name(from._internal_trace_name());
2152 }
2153 if (cached_has_bits & 0x00000002u) {
2154 _this->_impl_.pid_ = from._impl_.pid_;
2155 }
2156 if (cached_has_bits & 0x00000004u) {
2157 _this->_impl_.trace_begin_ = from._impl_.trace_begin_;
2158 }
2159 _this->_impl_._has_bits_[0] |= cached_has_bits;
2160 }
2161 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2162 }
2163
CopyFrom(const TracingMarkWriteFtraceEvent & from)2164 void TracingMarkWriteFtraceEvent::CopyFrom(const TracingMarkWriteFtraceEvent& from) {
2165 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TracingMarkWriteFtraceEvent)
2166 if (&from == this) return;
2167 Clear();
2168 MergeFrom(from);
2169 }
2170
IsInitialized() const2171 bool TracingMarkWriteFtraceEvent::IsInitialized() const {
2172 return true;
2173 }
2174
InternalSwap(TracingMarkWriteFtraceEvent * other)2175 void TracingMarkWriteFtraceEvent::InternalSwap(TracingMarkWriteFtraceEvent* other) {
2176 using std::swap;
2177 auto* lhs_arena = GetArenaForAllocation();
2178 auto* rhs_arena = other->GetArenaForAllocation();
2179 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2180 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2181 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2182 &_impl_.trace_name_, lhs_arena,
2183 &other->_impl_.trace_name_, rhs_arena
2184 );
2185 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2186 PROTOBUF_FIELD_OFFSET(TracingMarkWriteFtraceEvent, _impl_.trace_begin_)
2187 + sizeof(TracingMarkWriteFtraceEvent::_impl_.trace_begin_) // NOLINT
2188 - PROTOBUF_FIELD_OFFSET(TracingMarkWriteFtraceEvent, _impl_.pid_)>(
2189 reinterpret_cast<char*>(&_impl_.pid_),
2190 reinterpret_cast<char*>(&other->_impl_.pid_));
2191 }
2192
GetTypeName() const2193 std::string TracingMarkWriteFtraceEvent::GetTypeName() const {
2194 return "perfetto.protos.TracingMarkWriteFtraceEvent";
2195 }
2196
2197
2198 // ===================================================================
2199
2200 class MdpCmdPingpongDoneFtraceEvent::_Internal {
2201 public:
2202 using HasBits = decltype(std::declval<MdpCmdPingpongDoneFtraceEvent>()._impl_._has_bits_);
set_has_ctl_num(HasBits * has_bits)2203 static void set_has_ctl_num(HasBits* has_bits) {
2204 (*has_bits)[0] |= 1u;
2205 }
set_has_intf_num(HasBits * has_bits)2206 static void set_has_intf_num(HasBits* has_bits) {
2207 (*has_bits)[0] |= 2u;
2208 }
set_has_pp_num(HasBits * has_bits)2209 static void set_has_pp_num(HasBits* has_bits) {
2210 (*has_bits)[0] |= 4u;
2211 }
set_has_koff_cnt(HasBits * has_bits)2212 static void set_has_koff_cnt(HasBits* has_bits) {
2213 (*has_bits)[0] |= 8u;
2214 }
2215 };
2216
MdpCmdPingpongDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2217 MdpCmdPingpongDoneFtraceEvent::MdpCmdPingpongDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2218 bool is_message_owned)
2219 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2220 SharedCtor(arena, is_message_owned);
2221 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2222 }
MdpCmdPingpongDoneFtraceEvent(const MdpCmdPingpongDoneFtraceEvent & from)2223 MdpCmdPingpongDoneFtraceEvent::MdpCmdPingpongDoneFtraceEvent(const MdpCmdPingpongDoneFtraceEvent& from)
2224 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2225 MdpCmdPingpongDoneFtraceEvent* const _this = this; (void)_this;
2226 new (&_impl_) Impl_{
2227 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2228 , /*decltype(_impl_._cached_size_)*/{}
2229 , decltype(_impl_.ctl_num_){}
2230 , decltype(_impl_.intf_num_){}
2231 , decltype(_impl_.pp_num_){}
2232 , decltype(_impl_.koff_cnt_){}};
2233
2234 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2235 ::memcpy(&_impl_.ctl_num_, &from._impl_.ctl_num_,
2236 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.koff_cnt_) -
2237 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.koff_cnt_));
2238 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2239 }
2240
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2241 inline void MdpCmdPingpongDoneFtraceEvent::SharedCtor(
2242 ::_pb::Arena* arena, bool is_message_owned) {
2243 (void)arena;
2244 (void)is_message_owned;
2245 new (&_impl_) Impl_{
2246 decltype(_impl_._has_bits_){}
2247 , /*decltype(_impl_._cached_size_)*/{}
2248 , decltype(_impl_.ctl_num_){0u}
2249 , decltype(_impl_.intf_num_){0u}
2250 , decltype(_impl_.pp_num_){0u}
2251 , decltype(_impl_.koff_cnt_){0}
2252 };
2253 }
2254
~MdpCmdPingpongDoneFtraceEvent()2255 MdpCmdPingpongDoneFtraceEvent::~MdpCmdPingpongDoneFtraceEvent() {
2256 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2257 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2258 (void)arena;
2259 return;
2260 }
2261 SharedDtor();
2262 }
2263
SharedDtor()2264 inline void MdpCmdPingpongDoneFtraceEvent::SharedDtor() {
2265 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2266 }
2267
SetCachedSize(int size) const2268 void MdpCmdPingpongDoneFtraceEvent::SetCachedSize(int size) const {
2269 _impl_._cached_size_.Set(size);
2270 }
2271
Clear()2272 void MdpCmdPingpongDoneFtraceEvent::Clear() {
2273 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2274 ::uint32_t cached_has_bits = 0;
2275 // Prevent compiler warnings about cached_has_bits being unused
2276 (void) cached_has_bits;
2277
2278 cached_has_bits = _impl_._has_bits_[0];
2279 if (cached_has_bits & 0x0000000fu) {
2280 ::memset(&_impl_.ctl_num_, 0, static_cast<size_t>(
2281 reinterpret_cast<char*>(&_impl_.koff_cnt_) -
2282 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.koff_cnt_));
2283 }
2284 _impl_._has_bits_.Clear();
2285 _internal_metadata_.Clear<std::string>();
2286 }
2287
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2288 const char* MdpCmdPingpongDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2289 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2290 _Internal::HasBits has_bits{};
2291 while (!ctx->Done(&ptr)) {
2292 ::uint32_t tag;
2293 ptr = ::_pbi::ReadTag(ptr, &tag);
2294 switch (tag >> 3) {
2295 // optional uint32 ctl_num = 1;
2296 case 1:
2297 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2298 _Internal::set_has_ctl_num(&has_bits);
2299 _impl_.ctl_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2300 CHK_(ptr);
2301 } else {
2302 goto handle_unusual;
2303 }
2304 continue;
2305 // optional uint32 intf_num = 2;
2306 case 2:
2307 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2308 _Internal::set_has_intf_num(&has_bits);
2309 _impl_.intf_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2310 CHK_(ptr);
2311 } else {
2312 goto handle_unusual;
2313 }
2314 continue;
2315 // optional uint32 pp_num = 3;
2316 case 3:
2317 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2318 _Internal::set_has_pp_num(&has_bits);
2319 _impl_.pp_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2320 CHK_(ptr);
2321 } else {
2322 goto handle_unusual;
2323 }
2324 continue;
2325 // optional int32 koff_cnt = 4;
2326 case 4:
2327 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2328 _Internal::set_has_koff_cnt(&has_bits);
2329 _impl_.koff_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2330 CHK_(ptr);
2331 } else {
2332 goto handle_unusual;
2333 }
2334 continue;
2335 default:
2336 goto handle_unusual;
2337 } // switch
2338 handle_unusual:
2339 if ((tag == 0) || ((tag & 7) == 4)) {
2340 CHK_(ptr);
2341 ctx->SetLastTag(tag);
2342 goto message_done;
2343 }
2344 ptr = UnknownFieldParse(
2345 tag,
2346 _internal_metadata_.mutable_unknown_fields<std::string>(),
2347 ptr, ctx);
2348 CHK_(ptr != nullptr);
2349 } // while
2350 message_done:
2351 _impl_._has_bits_.Or(has_bits);
2352 return ptr;
2353 failure:
2354 ptr = nullptr;
2355 goto message_done;
2356 #undef CHK_
2357 }
2358
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2359 ::uint8_t* MdpCmdPingpongDoneFtraceEvent::_InternalSerialize(
2360 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2361 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2362 ::uint32_t cached_has_bits = 0;
2363 (void) cached_has_bits;
2364
2365 cached_has_bits = _impl_._has_bits_[0];
2366 // optional uint32 ctl_num = 1;
2367 if (cached_has_bits & 0x00000001u) {
2368 target = stream->EnsureSpace(target);
2369 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ctl_num(), target);
2370 }
2371
2372 // optional uint32 intf_num = 2;
2373 if (cached_has_bits & 0x00000002u) {
2374 target = stream->EnsureSpace(target);
2375 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_intf_num(), target);
2376 }
2377
2378 // optional uint32 pp_num = 3;
2379 if (cached_has_bits & 0x00000004u) {
2380 target = stream->EnsureSpace(target);
2381 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_pp_num(), target);
2382 }
2383
2384 // optional int32 koff_cnt = 4;
2385 if (cached_has_bits & 0x00000008u) {
2386 target = stream->EnsureSpace(target);
2387 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_koff_cnt(), target);
2388 }
2389
2390 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2391 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2392 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2393 }
2394 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2395 return target;
2396 }
2397
ByteSizeLong() const2398 size_t MdpCmdPingpongDoneFtraceEvent::ByteSizeLong() const {
2399 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2400 size_t total_size = 0;
2401
2402 ::uint32_t cached_has_bits = 0;
2403 // Prevent compiler warnings about cached_has_bits being unused
2404 (void) cached_has_bits;
2405
2406 cached_has_bits = _impl_._has_bits_[0];
2407 if (cached_has_bits & 0x0000000fu) {
2408 // optional uint32 ctl_num = 1;
2409 if (cached_has_bits & 0x00000001u) {
2410 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ctl_num());
2411 }
2412
2413 // optional uint32 intf_num = 2;
2414 if (cached_has_bits & 0x00000002u) {
2415 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_intf_num());
2416 }
2417
2418 // optional uint32 pp_num = 3;
2419 if (cached_has_bits & 0x00000004u) {
2420 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pp_num());
2421 }
2422
2423 // optional int32 koff_cnt = 4;
2424 if (cached_has_bits & 0x00000008u) {
2425 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_koff_cnt());
2426 }
2427
2428 }
2429 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2430 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2431 }
2432 int cached_size = ::_pbi::ToCachedSize(total_size);
2433 SetCachedSize(cached_size);
2434 return total_size;
2435 }
2436
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2437 void MdpCmdPingpongDoneFtraceEvent::CheckTypeAndMergeFrom(
2438 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2439 MergeFrom(*::_pbi::DownCast<const MdpCmdPingpongDoneFtraceEvent*>(
2440 &from));
2441 }
2442
MergeFrom(const MdpCmdPingpongDoneFtraceEvent & from)2443 void MdpCmdPingpongDoneFtraceEvent::MergeFrom(const MdpCmdPingpongDoneFtraceEvent& from) {
2444 MdpCmdPingpongDoneFtraceEvent* const _this = this;
2445 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2446 GOOGLE_DCHECK_NE(&from, _this);
2447 ::uint32_t cached_has_bits = 0;
2448 (void) cached_has_bits;
2449
2450 cached_has_bits = from._impl_._has_bits_[0];
2451 if (cached_has_bits & 0x0000000fu) {
2452 if (cached_has_bits & 0x00000001u) {
2453 _this->_impl_.ctl_num_ = from._impl_.ctl_num_;
2454 }
2455 if (cached_has_bits & 0x00000002u) {
2456 _this->_impl_.intf_num_ = from._impl_.intf_num_;
2457 }
2458 if (cached_has_bits & 0x00000004u) {
2459 _this->_impl_.pp_num_ = from._impl_.pp_num_;
2460 }
2461 if (cached_has_bits & 0x00000008u) {
2462 _this->_impl_.koff_cnt_ = from._impl_.koff_cnt_;
2463 }
2464 _this->_impl_._has_bits_[0] |= cached_has_bits;
2465 }
2466 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2467 }
2468
CopyFrom(const MdpCmdPingpongDoneFtraceEvent & from)2469 void MdpCmdPingpongDoneFtraceEvent::CopyFrom(const MdpCmdPingpongDoneFtraceEvent& from) {
2470 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCmdPingpongDoneFtraceEvent)
2471 if (&from == this) return;
2472 Clear();
2473 MergeFrom(from);
2474 }
2475
IsInitialized() const2476 bool MdpCmdPingpongDoneFtraceEvent::IsInitialized() const {
2477 return true;
2478 }
2479
InternalSwap(MdpCmdPingpongDoneFtraceEvent * other)2480 void MdpCmdPingpongDoneFtraceEvent::InternalSwap(MdpCmdPingpongDoneFtraceEvent* other) {
2481 using std::swap;
2482 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2483 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2484 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2485 PROTOBUF_FIELD_OFFSET(MdpCmdPingpongDoneFtraceEvent, _impl_.koff_cnt_)
2486 + sizeof(MdpCmdPingpongDoneFtraceEvent::_impl_.koff_cnt_) // NOLINT
2487 - PROTOBUF_FIELD_OFFSET(MdpCmdPingpongDoneFtraceEvent, _impl_.ctl_num_)>(
2488 reinterpret_cast<char*>(&_impl_.ctl_num_),
2489 reinterpret_cast<char*>(&other->_impl_.ctl_num_));
2490 }
2491
GetTypeName() const2492 std::string MdpCmdPingpongDoneFtraceEvent::GetTypeName() const {
2493 return "perfetto.protos.MdpCmdPingpongDoneFtraceEvent";
2494 }
2495
2496
2497 // ===================================================================
2498
2499 class MdpCompareBwFtraceEvent::_Internal {
2500 public:
2501 using HasBits = decltype(std::declval<MdpCompareBwFtraceEvent>()._impl_._has_bits_);
set_has_new_ab(HasBits * has_bits)2502 static void set_has_new_ab(HasBits* has_bits) {
2503 (*has_bits)[0] |= 1u;
2504 }
set_has_new_ib(HasBits * has_bits)2505 static void set_has_new_ib(HasBits* has_bits) {
2506 (*has_bits)[0] |= 2u;
2507 }
set_has_new_wb(HasBits * has_bits)2508 static void set_has_new_wb(HasBits* has_bits) {
2509 (*has_bits)[0] |= 4u;
2510 }
set_has_old_ab(HasBits * has_bits)2511 static void set_has_old_ab(HasBits* has_bits) {
2512 (*has_bits)[0] |= 8u;
2513 }
set_has_old_ib(HasBits * has_bits)2514 static void set_has_old_ib(HasBits* has_bits) {
2515 (*has_bits)[0] |= 16u;
2516 }
set_has_old_wb(HasBits * has_bits)2517 static void set_has_old_wb(HasBits* has_bits) {
2518 (*has_bits)[0] |= 32u;
2519 }
set_has_params_changed(HasBits * has_bits)2520 static void set_has_params_changed(HasBits* has_bits) {
2521 (*has_bits)[0] |= 64u;
2522 }
set_has_update_bw(HasBits * has_bits)2523 static void set_has_update_bw(HasBits* has_bits) {
2524 (*has_bits)[0] |= 128u;
2525 }
2526 };
2527
MdpCompareBwFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2528 MdpCompareBwFtraceEvent::MdpCompareBwFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2529 bool is_message_owned)
2530 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2531 SharedCtor(arena, is_message_owned);
2532 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCompareBwFtraceEvent)
2533 }
MdpCompareBwFtraceEvent(const MdpCompareBwFtraceEvent & from)2534 MdpCompareBwFtraceEvent::MdpCompareBwFtraceEvent(const MdpCompareBwFtraceEvent& from)
2535 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2536 MdpCompareBwFtraceEvent* const _this = this; (void)_this;
2537 new (&_impl_) Impl_{
2538 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2539 , /*decltype(_impl_._cached_size_)*/{}
2540 , decltype(_impl_.new_ab_){}
2541 , decltype(_impl_.new_ib_){}
2542 , decltype(_impl_.new_wb_){}
2543 , decltype(_impl_.old_ab_){}
2544 , decltype(_impl_.old_ib_){}
2545 , decltype(_impl_.old_wb_){}
2546 , decltype(_impl_.params_changed_){}
2547 , decltype(_impl_.update_bw_){}};
2548
2549 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2550 ::memcpy(&_impl_.new_ab_, &from._impl_.new_ab_,
2551 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.update_bw_) -
2552 reinterpret_cast<char*>(&_impl_.new_ab_)) + sizeof(_impl_.update_bw_));
2553 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCompareBwFtraceEvent)
2554 }
2555
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2556 inline void MdpCompareBwFtraceEvent::SharedCtor(
2557 ::_pb::Arena* arena, bool is_message_owned) {
2558 (void)arena;
2559 (void)is_message_owned;
2560 new (&_impl_) Impl_{
2561 decltype(_impl_._has_bits_){}
2562 , /*decltype(_impl_._cached_size_)*/{}
2563 , decltype(_impl_.new_ab_){::uint64_t{0u}}
2564 , decltype(_impl_.new_ib_){::uint64_t{0u}}
2565 , decltype(_impl_.new_wb_){::uint64_t{0u}}
2566 , decltype(_impl_.old_ab_){::uint64_t{0u}}
2567 , decltype(_impl_.old_ib_){::uint64_t{0u}}
2568 , decltype(_impl_.old_wb_){::uint64_t{0u}}
2569 , decltype(_impl_.params_changed_){0u}
2570 , decltype(_impl_.update_bw_){0u}
2571 };
2572 }
2573
~MdpCompareBwFtraceEvent()2574 MdpCompareBwFtraceEvent::~MdpCompareBwFtraceEvent() {
2575 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCompareBwFtraceEvent)
2576 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2577 (void)arena;
2578 return;
2579 }
2580 SharedDtor();
2581 }
2582
SharedDtor()2583 inline void MdpCompareBwFtraceEvent::SharedDtor() {
2584 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2585 }
2586
SetCachedSize(int size) const2587 void MdpCompareBwFtraceEvent::SetCachedSize(int size) const {
2588 _impl_._cached_size_.Set(size);
2589 }
2590
Clear()2591 void MdpCompareBwFtraceEvent::Clear() {
2592 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCompareBwFtraceEvent)
2593 ::uint32_t cached_has_bits = 0;
2594 // Prevent compiler warnings about cached_has_bits being unused
2595 (void) cached_has_bits;
2596
2597 cached_has_bits = _impl_._has_bits_[0];
2598 if (cached_has_bits & 0x000000ffu) {
2599 ::memset(&_impl_.new_ab_, 0, static_cast<size_t>(
2600 reinterpret_cast<char*>(&_impl_.update_bw_) -
2601 reinterpret_cast<char*>(&_impl_.new_ab_)) + sizeof(_impl_.update_bw_));
2602 }
2603 _impl_._has_bits_.Clear();
2604 _internal_metadata_.Clear<std::string>();
2605 }
2606
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2607 const char* MdpCompareBwFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2608 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2609 _Internal::HasBits has_bits{};
2610 while (!ctx->Done(&ptr)) {
2611 ::uint32_t tag;
2612 ptr = ::_pbi::ReadTag(ptr, &tag);
2613 switch (tag >> 3) {
2614 // optional uint64 new_ab = 1;
2615 case 1:
2616 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2617 _Internal::set_has_new_ab(&has_bits);
2618 _impl_.new_ab_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2619 CHK_(ptr);
2620 } else {
2621 goto handle_unusual;
2622 }
2623 continue;
2624 // optional uint64 new_ib = 2;
2625 case 2:
2626 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2627 _Internal::set_has_new_ib(&has_bits);
2628 _impl_.new_ib_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2629 CHK_(ptr);
2630 } else {
2631 goto handle_unusual;
2632 }
2633 continue;
2634 // optional uint64 new_wb = 3;
2635 case 3:
2636 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2637 _Internal::set_has_new_wb(&has_bits);
2638 _impl_.new_wb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2639 CHK_(ptr);
2640 } else {
2641 goto handle_unusual;
2642 }
2643 continue;
2644 // optional uint64 old_ab = 4;
2645 case 4:
2646 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2647 _Internal::set_has_old_ab(&has_bits);
2648 _impl_.old_ab_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2649 CHK_(ptr);
2650 } else {
2651 goto handle_unusual;
2652 }
2653 continue;
2654 // optional uint64 old_ib = 5;
2655 case 5:
2656 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
2657 _Internal::set_has_old_ib(&has_bits);
2658 _impl_.old_ib_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2659 CHK_(ptr);
2660 } else {
2661 goto handle_unusual;
2662 }
2663 continue;
2664 // optional uint64 old_wb = 6;
2665 case 6:
2666 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
2667 _Internal::set_has_old_wb(&has_bits);
2668 _impl_.old_wb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2669 CHK_(ptr);
2670 } else {
2671 goto handle_unusual;
2672 }
2673 continue;
2674 // optional uint32 params_changed = 7;
2675 case 7:
2676 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
2677 _Internal::set_has_params_changed(&has_bits);
2678 _impl_.params_changed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2679 CHK_(ptr);
2680 } else {
2681 goto handle_unusual;
2682 }
2683 continue;
2684 // optional uint32 update_bw = 8;
2685 case 8:
2686 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
2687 _Internal::set_has_update_bw(&has_bits);
2688 _impl_.update_bw_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2689 CHK_(ptr);
2690 } else {
2691 goto handle_unusual;
2692 }
2693 continue;
2694 default:
2695 goto handle_unusual;
2696 } // switch
2697 handle_unusual:
2698 if ((tag == 0) || ((tag & 7) == 4)) {
2699 CHK_(ptr);
2700 ctx->SetLastTag(tag);
2701 goto message_done;
2702 }
2703 ptr = UnknownFieldParse(
2704 tag,
2705 _internal_metadata_.mutable_unknown_fields<std::string>(),
2706 ptr, ctx);
2707 CHK_(ptr != nullptr);
2708 } // while
2709 message_done:
2710 _impl_._has_bits_.Or(has_bits);
2711 return ptr;
2712 failure:
2713 ptr = nullptr;
2714 goto message_done;
2715 #undef CHK_
2716 }
2717
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2718 ::uint8_t* MdpCompareBwFtraceEvent::_InternalSerialize(
2719 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2720 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCompareBwFtraceEvent)
2721 ::uint32_t cached_has_bits = 0;
2722 (void) cached_has_bits;
2723
2724 cached_has_bits = _impl_._has_bits_[0];
2725 // optional uint64 new_ab = 1;
2726 if (cached_has_bits & 0x00000001u) {
2727 target = stream->EnsureSpace(target);
2728 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_new_ab(), target);
2729 }
2730
2731 // optional uint64 new_ib = 2;
2732 if (cached_has_bits & 0x00000002u) {
2733 target = stream->EnsureSpace(target);
2734 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_new_ib(), target);
2735 }
2736
2737 // optional uint64 new_wb = 3;
2738 if (cached_has_bits & 0x00000004u) {
2739 target = stream->EnsureSpace(target);
2740 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_new_wb(), target);
2741 }
2742
2743 // optional uint64 old_ab = 4;
2744 if (cached_has_bits & 0x00000008u) {
2745 target = stream->EnsureSpace(target);
2746 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_old_ab(), target);
2747 }
2748
2749 // optional uint64 old_ib = 5;
2750 if (cached_has_bits & 0x00000010u) {
2751 target = stream->EnsureSpace(target);
2752 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_old_ib(), target);
2753 }
2754
2755 // optional uint64 old_wb = 6;
2756 if (cached_has_bits & 0x00000020u) {
2757 target = stream->EnsureSpace(target);
2758 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_old_wb(), target);
2759 }
2760
2761 // optional uint32 params_changed = 7;
2762 if (cached_has_bits & 0x00000040u) {
2763 target = stream->EnsureSpace(target);
2764 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_params_changed(), target);
2765 }
2766
2767 // optional uint32 update_bw = 8;
2768 if (cached_has_bits & 0x00000080u) {
2769 target = stream->EnsureSpace(target);
2770 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_update_bw(), target);
2771 }
2772
2773 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2774 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2775 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2776 }
2777 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCompareBwFtraceEvent)
2778 return target;
2779 }
2780
ByteSizeLong() const2781 size_t MdpCompareBwFtraceEvent::ByteSizeLong() const {
2782 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCompareBwFtraceEvent)
2783 size_t total_size = 0;
2784
2785 ::uint32_t cached_has_bits = 0;
2786 // Prevent compiler warnings about cached_has_bits being unused
2787 (void) cached_has_bits;
2788
2789 cached_has_bits = _impl_._has_bits_[0];
2790 if (cached_has_bits & 0x000000ffu) {
2791 // optional uint64 new_ab = 1;
2792 if (cached_has_bits & 0x00000001u) {
2793 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_new_ab());
2794 }
2795
2796 // optional uint64 new_ib = 2;
2797 if (cached_has_bits & 0x00000002u) {
2798 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_new_ib());
2799 }
2800
2801 // optional uint64 new_wb = 3;
2802 if (cached_has_bits & 0x00000004u) {
2803 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_new_wb());
2804 }
2805
2806 // optional uint64 old_ab = 4;
2807 if (cached_has_bits & 0x00000008u) {
2808 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_ab());
2809 }
2810
2811 // optional uint64 old_ib = 5;
2812 if (cached_has_bits & 0x00000010u) {
2813 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_ib());
2814 }
2815
2816 // optional uint64 old_wb = 6;
2817 if (cached_has_bits & 0x00000020u) {
2818 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_old_wb());
2819 }
2820
2821 // optional uint32 params_changed = 7;
2822 if (cached_has_bits & 0x00000040u) {
2823 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_params_changed());
2824 }
2825
2826 // optional uint32 update_bw = 8;
2827 if (cached_has_bits & 0x00000080u) {
2828 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_update_bw());
2829 }
2830
2831 }
2832 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2833 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2834 }
2835 int cached_size = ::_pbi::ToCachedSize(total_size);
2836 SetCachedSize(cached_size);
2837 return total_size;
2838 }
2839
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2840 void MdpCompareBwFtraceEvent::CheckTypeAndMergeFrom(
2841 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2842 MergeFrom(*::_pbi::DownCast<const MdpCompareBwFtraceEvent*>(
2843 &from));
2844 }
2845
MergeFrom(const MdpCompareBwFtraceEvent & from)2846 void MdpCompareBwFtraceEvent::MergeFrom(const MdpCompareBwFtraceEvent& from) {
2847 MdpCompareBwFtraceEvent* const _this = this;
2848 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCompareBwFtraceEvent)
2849 GOOGLE_DCHECK_NE(&from, _this);
2850 ::uint32_t cached_has_bits = 0;
2851 (void) cached_has_bits;
2852
2853 cached_has_bits = from._impl_._has_bits_[0];
2854 if (cached_has_bits & 0x000000ffu) {
2855 if (cached_has_bits & 0x00000001u) {
2856 _this->_impl_.new_ab_ = from._impl_.new_ab_;
2857 }
2858 if (cached_has_bits & 0x00000002u) {
2859 _this->_impl_.new_ib_ = from._impl_.new_ib_;
2860 }
2861 if (cached_has_bits & 0x00000004u) {
2862 _this->_impl_.new_wb_ = from._impl_.new_wb_;
2863 }
2864 if (cached_has_bits & 0x00000008u) {
2865 _this->_impl_.old_ab_ = from._impl_.old_ab_;
2866 }
2867 if (cached_has_bits & 0x00000010u) {
2868 _this->_impl_.old_ib_ = from._impl_.old_ib_;
2869 }
2870 if (cached_has_bits & 0x00000020u) {
2871 _this->_impl_.old_wb_ = from._impl_.old_wb_;
2872 }
2873 if (cached_has_bits & 0x00000040u) {
2874 _this->_impl_.params_changed_ = from._impl_.params_changed_;
2875 }
2876 if (cached_has_bits & 0x00000080u) {
2877 _this->_impl_.update_bw_ = from._impl_.update_bw_;
2878 }
2879 _this->_impl_._has_bits_[0] |= cached_has_bits;
2880 }
2881 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2882 }
2883
CopyFrom(const MdpCompareBwFtraceEvent & from)2884 void MdpCompareBwFtraceEvent::CopyFrom(const MdpCompareBwFtraceEvent& from) {
2885 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCompareBwFtraceEvent)
2886 if (&from == this) return;
2887 Clear();
2888 MergeFrom(from);
2889 }
2890
IsInitialized() const2891 bool MdpCompareBwFtraceEvent::IsInitialized() const {
2892 return true;
2893 }
2894
InternalSwap(MdpCompareBwFtraceEvent * other)2895 void MdpCompareBwFtraceEvent::InternalSwap(MdpCompareBwFtraceEvent* other) {
2896 using std::swap;
2897 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2898 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2899 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2900 PROTOBUF_FIELD_OFFSET(MdpCompareBwFtraceEvent, _impl_.update_bw_)
2901 + sizeof(MdpCompareBwFtraceEvent::_impl_.update_bw_) // NOLINT
2902 - PROTOBUF_FIELD_OFFSET(MdpCompareBwFtraceEvent, _impl_.new_ab_)>(
2903 reinterpret_cast<char*>(&_impl_.new_ab_),
2904 reinterpret_cast<char*>(&other->_impl_.new_ab_));
2905 }
2906
GetTypeName() const2907 std::string MdpCompareBwFtraceEvent::GetTypeName() const {
2908 return "perfetto.protos.MdpCompareBwFtraceEvent";
2909 }
2910
2911
2912 // ===================================================================
2913
2914 class MdpPerfSetPanicLutsFtraceEvent::_Internal {
2915 public:
2916 using HasBits = decltype(std::declval<MdpPerfSetPanicLutsFtraceEvent>()._impl_._has_bits_);
set_has_pnum(HasBits * has_bits)2917 static void set_has_pnum(HasBits* has_bits) {
2918 (*has_bits)[0] |= 1u;
2919 }
set_has_fmt(HasBits * has_bits)2920 static void set_has_fmt(HasBits* has_bits) {
2921 (*has_bits)[0] |= 2u;
2922 }
set_has_mode(HasBits * has_bits)2923 static void set_has_mode(HasBits* has_bits) {
2924 (*has_bits)[0] |= 4u;
2925 }
set_has_panic_lut(HasBits * has_bits)2926 static void set_has_panic_lut(HasBits* has_bits) {
2927 (*has_bits)[0] |= 8u;
2928 }
set_has_robust_lut(HasBits * has_bits)2929 static void set_has_robust_lut(HasBits* has_bits) {
2930 (*has_bits)[0] |= 16u;
2931 }
2932 };
2933
MdpPerfSetPanicLutsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2934 MdpPerfSetPanicLutsFtraceEvent::MdpPerfSetPanicLutsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2935 bool is_message_owned)
2936 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2937 SharedCtor(arena, is_message_owned);
2938 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
2939 }
MdpPerfSetPanicLutsFtraceEvent(const MdpPerfSetPanicLutsFtraceEvent & from)2940 MdpPerfSetPanicLutsFtraceEvent::MdpPerfSetPanicLutsFtraceEvent(const MdpPerfSetPanicLutsFtraceEvent& from)
2941 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2942 MdpPerfSetPanicLutsFtraceEvent* const _this = this; (void)_this;
2943 new (&_impl_) Impl_{
2944 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2945 , /*decltype(_impl_._cached_size_)*/{}
2946 , decltype(_impl_.pnum_){}
2947 , decltype(_impl_.fmt_){}
2948 , decltype(_impl_.mode_){}
2949 , decltype(_impl_.panic_lut_){}
2950 , decltype(_impl_.robust_lut_){}};
2951
2952 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2953 ::memcpy(&_impl_.pnum_, &from._impl_.pnum_,
2954 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.robust_lut_) -
2955 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.robust_lut_));
2956 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
2957 }
2958
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2959 inline void MdpPerfSetPanicLutsFtraceEvent::SharedCtor(
2960 ::_pb::Arena* arena, bool is_message_owned) {
2961 (void)arena;
2962 (void)is_message_owned;
2963 new (&_impl_) Impl_{
2964 decltype(_impl_._has_bits_){}
2965 , /*decltype(_impl_._cached_size_)*/{}
2966 , decltype(_impl_.pnum_){0u}
2967 , decltype(_impl_.fmt_){0u}
2968 , decltype(_impl_.mode_){0u}
2969 , decltype(_impl_.panic_lut_){0u}
2970 , decltype(_impl_.robust_lut_){0u}
2971 };
2972 }
2973
~MdpPerfSetPanicLutsFtraceEvent()2974 MdpPerfSetPanicLutsFtraceEvent::~MdpPerfSetPanicLutsFtraceEvent() {
2975 // @@protoc_insertion_point(destructor:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
2976 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2977 (void)arena;
2978 return;
2979 }
2980 SharedDtor();
2981 }
2982
SharedDtor()2983 inline void MdpPerfSetPanicLutsFtraceEvent::SharedDtor() {
2984 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2985 }
2986
SetCachedSize(int size) const2987 void MdpPerfSetPanicLutsFtraceEvent::SetCachedSize(int size) const {
2988 _impl_._cached_size_.Set(size);
2989 }
2990
Clear()2991 void MdpPerfSetPanicLutsFtraceEvent::Clear() {
2992 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
2993 ::uint32_t cached_has_bits = 0;
2994 // Prevent compiler warnings about cached_has_bits being unused
2995 (void) cached_has_bits;
2996
2997 cached_has_bits = _impl_._has_bits_[0];
2998 if (cached_has_bits & 0x0000001fu) {
2999 ::memset(&_impl_.pnum_, 0, static_cast<size_t>(
3000 reinterpret_cast<char*>(&_impl_.robust_lut_) -
3001 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.robust_lut_));
3002 }
3003 _impl_._has_bits_.Clear();
3004 _internal_metadata_.Clear<std::string>();
3005 }
3006
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3007 const char* MdpPerfSetPanicLutsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3008 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3009 _Internal::HasBits has_bits{};
3010 while (!ctx->Done(&ptr)) {
3011 ::uint32_t tag;
3012 ptr = ::_pbi::ReadTag(ptr, &tag);
3013 switch (tag >> 3) {
3014 // optional uint32 pnum = 1;
3015 case 1:
3016 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3017 _Internal::set_has_pnum(&has_bits);
3018 _impl_.pnum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3019 CHK_(ptr);
3020 } else {
3021 goto handle_unusual;
3022 }
3023 continue;
3024 // optional uint32 fmt = 2;
3025 case 2:
3026 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3027 _Internal::set_has_fmt(&has_bits);
3028 _impl_.fmt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3029 CHK_(ptr);
3030 } else {
3031 goto handle_unusual;
3032 }
3033 continue;
3034 // optional uint32 mode = 3;
3035 case 3:
3036 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3037 _Internal::set_has_mode(&has_bits);
3038 _impl_.mode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3039 CHK_(ptr);
3040 } else {
3041 goto handle_unusual;
3042 }
3043 continue;
3044 // optional uint32 panic_lut = 4;
3045 case 4:
3046 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3047 _Internal::set_has_panic_lut(&has_bits);
3048 _impl_.panic_lut_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3049 CHK_(ptr);
3050 } else {
3051 goto handle_unusual;
3052 }
3053 continue;
3054 // optional uint32 robust_lut = 5;
3055 case 5:
3056 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3057 _Internal::set_has_robust_lut(&has_bits);
3058 _impl_.robust_lut_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3059 CHK_(ptr);
3060 } else {
3061 goto handle_unusual;
3062 }
3063 continue;
3064 default:
3065 goto handle_unusual;
3066 } // switch
3067 handle_unusual:
3068 if ((tag == 0) || ((tag & 7) == 4)) {
3069 CHK_(ptr);
3070 ctx->SetLastTag(tag);
3071 goto message_done;
3072 }
3073 ptr = UnknownFieldParse(
3074 tag,
3075 _internal_metadata_.mutable_unknown_fields<std::string>(),
3076 ptr, ctx);
3077 CHK_(ptr != nullptr);
3078 } // while
3079 message_done:
3080 _impl_._has_bits_.Or(has_bits);
3081 return ptr;
3082 failure:
3083 ptr = nullptr;
3084 goto message_done;
3085 #undef CHK_
3086 }
3087
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3088 ::uint8_t* MdpPerfSetPanicLutsFtraceEvent::_InternalSerialize(
3089 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3090 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
3091 ::uint32_t cached_has_bits = 0;
3092 (void) cached_has_bits;
3093
3094 cached_has_bits = _impl_._has_bits_[0];
3095 // optional uint32 pnum = 1;
3096 if (cached_has_bits & 0x00000001u) {
3097 target = stream->EnsureSpace(target);
3098 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pnum(), target);
3099 }
3100
3101 // optional uint32 fmt = 2;
3102 if (cached_has_bits & 0x00000002u) {
3103 target = stream->EnsureSpace(target);
3104 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_fmt(), target);
3105 }
3106
3107 // optional uint32 mode = 3;
3108 if (cached_has_bits & 0x00000004u) {
3109 target = stream->EnsureSpace(target);
3110 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_mode(), target);
3111 }
3112
3113 // optional uint32 panic_lut = 4;
3114 if (cached_has_bits & 0x00000008u) {
3115 target = stream->EnsureSpace(target);
3116 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_panic_lut(), target);
3117 }
3118
3119 // optional uint32 robust_lut = 5;
3120 if (cached_has_bits & 0x00000010u) {
3121 target = stream->EnsureSpace(target);
3122 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_robust_lut(), target);
3123 }
3124
3125 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3126 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3127 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3128 }
3129 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
3130 return target;
3131 }
3132
ByteSizeLong() const3133 size_t MdpPerfSetPanicLutsFtraceEvent::ByteSizeLong() const {
3134 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
3135 size_t total_size = 0;
3136
3137 ::uint32_t cached_has_bits = 0;
3138 // Prevent compiler warnings about cached_has_bits being unused
3139 (void) cached_has_bits;
3140
3141 cached_has_bits = _impl_._has_bits_[0];
3142 if (cached_has_bits & 0x0000001fu) {
3143 // optional uint32 pnum = 1;
3144 if (cached_has_bits & 0x00000001u) {
3145 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pnum());
3146 }
3147
3148 // optional uint32 fmt = 2;
3149 if (cached_has_bits & 0x00000002u) {
3150 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_fmt());
3151 }
3152
3153 // optional uint32 mode = 3;
3154 if (cached_has_bits & 0x00000004u) {
3155 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mode());
3156 }
3157
3158 // optional uint32 panic_lut = 4;
3159 if (cached_has_bits & 0x00000008u) {
3160 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_panic_lut());
3161 }
3162
3163 // optional uint32 robust_lut = 5;
3164 if (cached_has_bits & 0x00000010u) {
3165 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_robust_lut());
3166 }
3167
3168 }
3169 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3170 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3171 }
3172 int cached_size = ::_pbi::ToCachedSize(total_size);
3173 SetCachedSize(cached_size);
3174 return total_size;
3175 }
3176
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3177 void MdpPerfSetPanicLutsFtraceEvent::CheckTypeAndMergeFrom(
3178 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3179 MergeFrom(*::_pbi::DownCast<const MdpPerfSetPanicLutsFtraceEvent*>(
3180 &from));
3181 }
3182
MergeFrom(const MdpPerfSetPanicLutsFtraceEvent & from)3183 void MdpPerfSetPanicLutsFtraceEvent::MergeFrom(const MdpPerfSetPanicLutsFtraceEvent& from) {
3184 MdpPerfSetPanicLutsFtraceEvent* const _this = this;
3185 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
3186 GOOGLE_DCHECK_NE(&from, _this);
3187 ::uint32_t cached_has_bits = 0;
3188 (void) cached_has_bits;
3189
3190 cached_has_bits = from._impl_._has_bits_[0];
3191 if (cached_has_bits & 0x0000001fu) {
3192 if (cached_has_bits & 0x00000001u) {
3193 _this->_impl_.pnum_ = from._impl_.pnum_;
3194 }
3195 if (cached_has_bits & 0x00000002u) {
3196 _this->_impl_.fmt_ = from._impl_.fmt_;
3197 }
3198 if (cached_has_bits & 0x00000004u) {
3199 _this->_impl_.mode_ = from._impl_.mode_;
3200 }
3201 if (cached_has_bits & 0x00000008u) {
3202 _this->_impl_.panic_lut_ = from._impl_.panic_lut_;
3203 }
3204 if (cached_has_bits & 0x00000010u) {
3205 _this->_impl_.robust_lut_ = from._impl_.robust_lut_;
3206 }
3207 _this->_impl_._has_bits_[0] |= cached_has_bits;
3208 }
3209 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3210 }
3211
CopyFrom(const MdpPerfSetPanicLutsFtraceEvent & from)3212 void MdpPerfSetPanicLutsFtraceEvent::CopyFrom(const MdpPerfSetPanicLutsFtraceEvent& from) {
3213 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpPerfSetPanicLutsFtraceEvent)
3214 if (&from == this) return;
3215 Clear();
3216 MergeFrom(from);
3217 }
3218
IsInitialized() const3219 bool MdpPerfSetPanicLutsFtraceEvent::IsInitialized() const {
3220 return true;
3221 }
3222
InternalSwap(MdpPerfSetPanicLutsFtraceEvent * other)3223 void MdpPerfSetPanicLutsFtraceEvent::InternalSwap(MdpPerfSetPanicLutsFtraceEvent* other) {
3224 using std::swap;
3225 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3226 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3227 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3228 PROTOBUF_FIELD_OFFSET(MdpPerfSetPanicLutsFtraceEvent, _impl_.robust_lut_)
3229 + sizeof(MdpPerfSetPanicLutsFtraceEvent::_impl_.robust_lut_) // NOLINT
3230 - PROTOBUF_FIELD_OFFSET(MdpPerfSetPanicLutsFtraceEvent, _impl_.pnum_)>(
3231 reinterpret_cast<char*>(&_impl_.pnum_),
3232 reinterpret_cast<char*>(&other->_impl_.pnum_));
3233 }
3234
GetTypeName() const3235 std::string MdpPerfSetPanicLutsFtraceEvent::GetTypeName() const {
3236 return "perfetto.protos.MdpPerfSetPanicLutsFtraceEvent";
3237 }
3238
3239
3240 // ===================================================================
3241
3242 class MdpSsppSetFtraceEvent::_Internal {
3243 public:
3244 using HasBits = decltype(std::declval<MdpSsppSetFtraceEvent>()._impl_._has_bits_);
set_has_num(HasBits * has_bits)3245 static void set_has_num(HasBits* has_bits) {
3246 (*has_bits)[0] |= 1u;
3247 }
set_has_play_cnt(HasBits * has_bits)3248 static void set_has_play_cnt(HasBits* has_bits) {
3249 (*has_bits)[0] |= 2u;
3250 }
set_has_mixer(HasBits * has_bits)3251 static void set_has_mixer(HasBits* has_bits) {
3252 (*has_bits)[0] |= 4u;
3253 }
set_has_stage(HasBits * has_bits)3254 static void set_has_stage(HasBits* has_bits) {
3255 (*has_bits)[0] |= 8u;
3256 }
set_has_flags(HasBits * has_bits)3257 static void set_has_flags(HasBits* has_bits) {
3258 (*has_bits)[0] |= 16u;
3259 }
set_has_format(HasBits * has_bits)3260 static void set_has_format(HasBits* has_bits) {
3261 (*has_bits)[0] |= 32u;
3262 }
set_has_img_w(HasBits * has_bits)3263 static void set_has_img_w(HasBits* has_bits) {
3264 (*has_bits)[0] |= 64u;
3265 }
set_has_img_h(HasBits * has_bits)3266 static void set_has_img_h(HasBits* has_bits) {
3267 (*has_bits)[0] |= 128u;
3268 }
set_has_src_x(HasBits * has_bits)3269 static void set_has_src_x(HasBits* has_bits) {
3270 (*has_bits)[0] |= 256u;
3271 }
set_has_src_y(HasBits * has_bits)3272 static void set_has_src_y(HasBits* has_bits) {
3273 (*has_bits)[0] |= 512u;
3274 }
set_has_src_w(HasBits * has_bits)3275 static void set_has_src_w(HasBits* has_bits) {
3276 (*has_bits)[0] |= 1024u;
3277 }
set_has_src_h(HasBits * has_bits)3278 static void set_has_src_h(HasBits* has_bits) {
3279 (*has_bits)[0] |= 2048u;
3280 }
set_has_dst_x(HasBits * has_bits)3281 static void set_has_dst_x(HasBits* has_bits) {
3282 (*has_bits)[0] |= 4096u;
3283 }
set_has_dst_y(HasBits * has_bits)3284 static void set_has_dst_y(HasBits* has_bits) {
3285 (*has_bits)[0] |= 8192u;
3286 }
set_has_dst_w(HasBits * has_bits)3287 static void set_has_dst_w(HasBits* has_bits) {
3288 (*has_bits)[0] |= 16384u;
3289 }
set_has_dst_h(HasBits * has_bits)3290 static void set_has_dst_h(HasBits* has_bits) {
3291 (*has_bits)[0] |= 32768u;
3292 }
3293 };
3294
MdpSsppSetFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3295 MdpSsppSetFtraceEvent::MdpSsppSetFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3296 bool is_message_owned)
3297 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3298 SharedCtor(arena, is_message_owned);
3299 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpSsppSetFtraceEvent)
3300 }
MdpSsppSetFtraceEvent(const MdpSsppSetFtraceEvent & from)3301 MdpSsppSetFtraceEvent::MdpSsppSetFtraceEvent(const MdpSsppSetFtraceEvent& from)
3302 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3303 MdpSsppSetFtraceEvent* const _this = this; (void)_this;
3304 new (&_impl_) Impl_{
3305 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3306 , /*decltype(_impl_._cached_size_)*/{}
3307 , decltype(_impl_.num_){}
3308 , decltype(_impl_.play_cnt_){}
3309 , decltype(_impl_.mixer_){}
3310 , decltype(_impl_.stage_){}
3311 , decltype(_impl_.flags_){}
3312 , decltype(_impl_.format_){}
3313 , decltype(_impl_.img_w_){}
3314 , decltype(_impl_.img_h_){}
3315 , decltype(_impl_.src_x_){}
3316 , decltype(_impl_.src_y_){}
3317 , decltype(_impl_.src_w_){}
3318 , decltype(_impl_.src_h_){}
3319 , decltype(_impl_.dst_x_){}
3320 , decltype(_impl_.dst_y_){}
3321 , decltype(_impl_.dst_w_){}
3322 , decltype(_impl_.dst_h_){}};
3323
3324 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3325 ::memcpy(&_impl_.num_, &from._impl_.num_,
3326 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dst_h_) -
3327 reinterpret_cast<char*>(&_impl_.num_)) + sizeof(_impl_.dst_h_));
3328 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpSsppSetFtraceEvent)
3329 }
3330
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3331 inline void MdpSsppSetFtraceEvent::SharedCtor(
3332 ::_pb::Arena* arena, bool is_message_owned) {
3333 (void)arena;
3334 (void)is_message_owned;
3335 new (&_impl_) Impl_{
3336 decltype(_impl_._has_bits_){}
3337 , /*decltype(_impl_._cached_size_)*/{}
3338 , decltype(_impl_.num_){0u}
3339 , decltype(_impl_.play_cnt_){0u}
3340 , decltype(_impl_.mixer_){0u}
3341 , decltype(_impl_.stage_){0u}
3342 , decltype(_impl_.flags_){0u}
3343 , decltype(_impl_.format_){0u}
3344 , decltype(_impl_.img_w_){0u}
3345 , decltype(_impl_.img_h_){0u}
3346 , decltype(_impl_.src_x_){0u}
3347 , decltype(_impl_.src_y_){0u}
3348 , decltype(_impl_.src_w_){0u}
3349 , decltype(_impl_.src_h_){0u}
3350 , decltype(_impl_.dst_x_){0u}
3351 , decltype(_impl_.dst_y_){0u}
3352 , decltype(_impl_.dst_w_){0u}
3353 , decltype(_impl_.dst_h_){0u}
3354 };
3355 }
3356
~MdpSsppSetFtraceEvent()3357 MdpSsppSetFtraceEvent::~MdpSsppSetFtraceEvent() {
3358 // @@protoc_insertion_point(destructor:perfetto.protos.MdpSsppSetFtraceEvent)
3359 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3360 (void)arena;
3361 return;
3362 }
3363 SharedDtor();
3364 }
3365
SharedDtor()3366 inline void MdpSsppSetFtraceEvent::SharedDtor() {
3367 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3368 }
3369
SetCachedSize(int size) const3370 void MdpSsppSetFtraceEvent::SetCachedSize(int size) const {
3371 _impl_._cached_size_.Set(size);
3372 }
3373
Clear()3374 void MdpSsppSetFtraceEvent::Clear() {
3375 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpSsppSetFtraceEvent)
3376 ::uint32_t cached_has_bits = 0;
3377 // Prevent compiler warnings about cached_has_bits being unused
3378 (void) cached_has_bits;
3379
3380 cached_has_bits = _impl_._has_bits_[0];
3381 if (cached_has_bits & 0x000000ffu) {
3382 ::memset(&_impl_.num_, 0, static_cast<size_t>(
3383 reinterpret_cast<char*>(&_impl_.img_h_) -
3384 reinterpret_cast<char*>(&_impl_.num_)) + sizeof(_impl_.img_h_));
3385 }
3386 if (cached_has_bits & 0x0000ff00u) {
3387 ::memset(&_impl_.src_x_, 0, static_cast<size_t>(
3388 reinterpret_cast<char*>(&_impl_.dst_h_) -
3389 reinterpret_cast<char*>(&_impl_.src_x_)) + sizeof(_impl_.dst_h_));
3390 }
3391 _impl_._has_bits_.Clear();
3392 _internal_metadata_.Clear<std::string>();
3393 }
3394
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3395 const char* MdpSsppSetFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3396 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3397 _Internal::HasBits has_bits{};
3398 while (!ctx->Done(&ptr)) {
3399 ::uint32_t tag;
3400 ptr = ::_pbi::ReadTag(ptr, &tag);
3401 switch (tag >> 3) {
3402 // optional uint32 num = 1;
3403 case 1:
3404 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3405 _Internal::set_has_num(&has_bits);
3406 _impl_.num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3407 CHK_(ptr);
3408 } else {
3409 goto handle_unusual;
3410 }
3411 continue;
3412 // optional uint32 play_cnt = 2;
3413 case 2:
3414 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3415 _Internal::set_has_play_cnt(&has_bits);
3416 _impl_.play_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3417 CHK_(ptr);
3418 } else {
3419 goto handle_unusual;
3420 }
3421 continue;
3422 // optional uint32 mixer = 3;
3423 case 3:
3424 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3425 _Internal::set_has_mixer(&has_bits);
3426 _impl_.mixer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3427 CHK_(ptr);
3428 } else {
3429 goto handle_unusual;
3430 }
3431 continue;
3432 // optional uint32 stage = 4;
3433 case 4:
3434 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3435 _Internal::set_has_stage(&has_bits);
3436 _impl_.stage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3437 CHK_(ptr);
3438 } else {
3439 goto handle_unusual;
3440 }
3441 continue;
3442 // optional uint32 flags = 5;
3443 case 5:
3444 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
3445 _Internal::set_has_flags(&has_bits);
3446 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3447 CHK_(ptr);
3448 } else {
3449 goto handle_unusual;
3450 }
3451 continue;
3452 // optional uint32 format = 6;
3453 case 6:
3454 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
3455 _Internal::set_has_format(&has_bits);
3456 _impl_.format_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3457 CHK_(ptr);
3458 } else {
3459 goto handle_unusual;
3460 }
3461 continue;
3462 // optional uint32 img_w = 7;
3463 case 7:
3464 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
3465 _Internal::set_has_img_w(&has_bits);
3466 _impl_.img_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3467 CHK_(ptr);
3468 } else {
3469 goto handle_unusual;
3470 }
3471 continue;
3472 // optional uint32 img_h = 8;
3473 case 8:
3474 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
3475 _Internal::set_has_img_h(&has_bits);
3476 _impl_.img_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3477 CHK_(ptr);
3478 } else {
3479 goto handle_unusual;
3480 }
3481 continue;
3482 // optional uint32 src_x = 9;
3483 case 9:
3484 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
3485 _Internal::set_has_src_x(&has_bits);
3486 _impl_.src_x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3487 CHK_(ptr);
3488 } else {
3489 goto handle_unusual;
3490 }
3491 continue;
3492 // optional uint32 src_y = 10;
3493 case 10:
3494 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
3495 _Internal::set_has_src_y(&has_bits);
3496 _impl_.src_y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3497 CHK_(ptr);
3498 } else {
3499 goto handle_unusual;
3500 }
3501 continue;
3502 // optional uint32 src_w = 11;
3503 case 11:
3504 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
3505 _Internal::set_has_src_w(&has_bits);
3506 _impl_.src_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3507 CHK_(ptr);
3508 } else {
3509 goto handle_unusual;
3510 }
3511 continue;
3512 // optional uint32 src_h = 12;
3513 case 12:
3514 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
3515 _Internal::set_has_src_h(&has_bits);
3516 _impl_.src_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3517 CHK_(ptr);
3518 } else {
3519 goto handle_unusual;
3520 }
3521 continue;
3522 // optional uint32 dst_x = 13;
3523 case 13:
3524 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
3525 _Internal::set_has_dst_x(&has_bits);
3526 _impl_.dst_x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3527 CHK_(ptr);
3528 } else {
3529 goto handle_unusual;
3530 }
3531 continue;
3532 // optional uint32 dst_y = 14;
3533 case 14:
3534 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
3535 _Internal::set_has_dst_y(&has_bits);
3536 _impl_.dst_y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3537 CHK_(ptr);
3538 } else {
3539 goto handle_unusual;
3540 }
3541 continue;
3542 // optional uint32 dst_w = 15;
3543 case 15:
3544 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
3545 _Internal::set_has_dst_w(&has_bits);
3546 _impl_.dst_w_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3547 CHK_(ptr);
3548 } else {
3549 goto handle_unusual;
3550 }
3551 continue;
3552 // optional uint32 dst_h = 16;
3553 case 16:
3554 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
3555 _Internal::set_has_dst_h(&has_bits);
3556 _impl_.dst_h_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3557 CHK_(ptr);
3558 } else {
3559 goto handle_unusual;
3560 }
3561 continue;
3562 default:
3563 goto handle_unusual;
3564 } // switch
3565 handle_unusual:
3566 if ((tag == 0) || ((tag & 7) == 4)) {
3567 CHK_(ptr);
3568 ctx->SetLastTag(tag);
3569 goto message_done;
3570 }
3571 ptr = UnknownFieldParse(
3572 tag,
3573 _internal_metadata_.mutable_unknown_fields<std::string>(),
3574 ptr, ctx);
3575 CHK_(ptr != nullptr);
3576 } // while
3577 message_done:
3578 _impl_._has_bits_.Or(has_bits);
3579 return ptr;
3580 failure:
3581 ptr = nullptr;
3582 goto message_done;
3583 #undef CHK_
3584 }
3585
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3586 ::uint8_t* MdpSsppSetFtraceEvent::_InternalSerialize(
3587 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3588 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpSsppSetFtraceEvent)
3589 ::uint32_t cached_has_bits = 0;
3590 (void) cached_has_bits;
3591
3592 cached_has_bits = _impl_._has_bits_[0];
3593 // optional uint32 num = 1;
3594 if (cached_has_bits & 0x00000001u) {
3595 target = stream->EnsureSpace(target);
3596 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_num(), target);
3597 }
3598
3599 // optional uint32 play_cnt = 2;
3600 if (cached_has_bits & 0x00000002u) {
3601 target = stream->EnsureSpace(target);
3602 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_play_cnt(), target);
3603 }
3604
3605 // optional uint32 mixer = 3;
3606 if (cached_has_bits & 0x00000004u) {
3607 target = stream->EnsureSpace(target);
3608 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_mixer(), target);
3609 }
3610
3611 // optional uint32 stage = 4;
3612 if (cached_has_bits & 0x00000008u) {
3613 target = stream->EnsureSpace(target);
3614 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_stage(), target);
3615 }
3616
3617 // optional uint32 flags = 5;
3618 if (cached_has_bits & 0x00000010u) {
3619 target = stream->EnsureSpace(target);
3620 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_flags(), target);
3621 }
3622
3623 // optional uint32 format = 6;
3624 if (cached_has_bits & 0x00000020u) {
3625 target = stream->EnsureSpace(target);
3626 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_format(), target);
3627 }
3628
3629 // optional uint32 img_w = 7;
3630 if (cached_has_bits & 0x00000040u) {
3631 target = stream->EnsureSpace(target);
3632 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_img_w(), target);
3633 }
3634
3635 // optional uint32 img_h = 8;
3636 if (cached_has_bits & 0x00000080u) {
3637 target = stream->EnsureSpace(target);
3638 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_img_h(), target);
3639 }
3640
3641 // optional uint32 src_x = 9;
3642 if (cached_has_bits & 0x00000100u) {
3643 target = stream->EnsureSpace(target);
3644 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_src_x(), target);
3645 }
3646
3647 // optional uint32 src_y = 10;
3648 if (cached_has_bits & 0x00000200u) {
3649 target = stream->EnsureSpace(target);
3650 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_src_y(), target);
3651 }
3652
3653 // optional uint32 src_w = 11;
3654 if (cached_has_bits & 0x00000400u) {
3655 target = stream->EnsureSpace(target);
3656 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_src_w(), target);
3657 }
3658
3659 // optional uint32 src_h = 12;
3660 if (cached_has_bits & 0x00000800u) {
3661 target = stream->EnsureSpace(target);
3662 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(12, this->_internal_src_h(), target);
3663 }
3664
3665 // optional uint32 dst_x = 13;
3666 if (cached_has_bits & 0x00001000u) {
3667 target = stream->EnsureSpace(target);
3668 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(13, this->_internal_dst_x(), target);
3669 }
3670
3671 // optional uint32 dst_y = 14;
3672 if (cached_has_bits & 0x00002000u) {
3673 target = stream->EnsureSpace(target);
3674 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(14, this->_internal_dst_y(), target);
3675 }
3676
3677 // optional uint32 dst_w = 15;
3678 if (cached_has_bits & 0x00004000u) {
3679 target = stream->EnsureSpace(target);
3680 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(15, this->_internal_dst_w(), target);
3681 }
3682
3683 // optional uint32 dst_h = 16;
3684 if (cached_has_bits & 0x00008000u) {
3685 target = stream->EnsureSpace(target);
3686 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_dst_h(), target);
3687 }
3688
3689 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3690 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3691 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3692 }
3693 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpSsppSetFtraceEvent)
3694 return target;
3695 }
3696
ByteSizeLong() const3697 size_t MdpSsppSetFtraceEvent::ByteSizeLong() const {
3698 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpSsppSetFtraceEvent)
3699 size_t total_size = 0;
3700
3701 ::uint32_t cached_has_bits = 0;
3702 // Prevent compiler warnings about cached_has_bits being unused
3703 (void) cached_has_bits;
3704
3705 cached_has_bits = _impl_._has_bits_[0];
3706 if (cached_has_bits & 0x000000ffu) {
3707 // optional uint32 num = 1;
3708 if (cached_has_bits & 0x00000001u) {
3709 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_num());
3710 }
3711
3712 // optional uint32 play_cnt = 2;
3713 if (cached_has_bits & 0x00000002u) {
3714 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_play_cnt());
3715 }
3716
3717 // optional uint32 mixer = 3;
3718 if (cached_has_bits & 0x00000004u) {
3719 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mixer());
3720 }
3721
3722 // optional uint32 stage = 4;
3723 if (cached_has_bits & 0x00000008u) {
3724 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_stage());
3725 }
3726
3727 // optional uint32 flags = 5;
3728 if (cached_has_bits & 0x00000010u) {
3729 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
3730 }
3731
3732 // optional uint32 format = 6;
3733 if (cached_has_bits & 0x00000020u) {
3734 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_format());
3735 }
3736
3737 // optional uint32 img_w = 7;
3738 if (cached_has_bits & 0x00000040u) {
3739 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_img_w());
3740 }
3741
3742 // optional uint32 img_h = 8;
3743 if (cached_has_bits & 0x00000080u) {
3744 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_img_h());
3745 }
3746
3747 }
3748 if (cached_has_bits & 0x0000ff00u) {
3749 // optional uint32 src_x = 9;
3750 if (cached_has_bits & 0x00000100u) {
3751 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_x());
3752 }
3753
3754 // optional uint32 src_y = 10;
3755 if (cached_has_bits & 0x00000200u) {
3756 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_y());
3757 }
3758
3759 // optional uint32 src_w = 11;
3760 if (cached_has_bits & 0x00000400u) {
3761 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_w());
3762 }
3763
3764 // optional uint32 src_h = 12;
3765 if (cached_has_bits & 0x00000800u) {
3766 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_src_h());
3767 }
3768
3769 // optional uint32 dst_x = 13;
3770 if (cached_has_bits & 0x00001000u) {
3771 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dst_x());
3772 }
3773
3774 // optional uint32 dst_y = 14;
3775 if (cached_has_bits & 0x00002000u) {
3776 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dst_y());
3777 }
3778
3779 // optional uint32 dst_w = 15;
3780 if (cached_has_bits & 0x00004000u) {
3781 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dst_w());
3782 }
3783
3784 // optional uint32 dst_h = 16;
3785 if (cached_has_bits & 0x00008000u) {
3786 total_size += 2 +
3787 ::_pbi::WireFormatLite::UInt32Size(
3788 this->_internal_dst_h());
3789 }
3790
3791 }
3792 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3793 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3794 }
3795 int cached_size = ::_pbi::ToCachedSize(total_size);
3796 SetCachedSize(cached_size);
3797 return total_size;
3798 }
3799
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3800 void MdpSsppSetFtraceEvent::CheckTypeAndMergeFrom(
3801 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3802 MergeFrom(*::_pbi::DownCast<const MdpSsppSetFtraceEvent*>(
3803 &from));
3804 }
3805
MergeFrom(const MdpSsppSetFtraceEvent & from)3806 void MdpSsppSetFtraceEvent::MergeFrom(const MdpSsppSetFtraceEvent& from) {
3807 MdpSsppSetFtraceEvent* const _this = this;
3808 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpSsppSetFtraceEvent)
3809 GOOGLE_DCHECK_NE(&from, _this);
3810 ::uint32_t cached_has_bits = 0;
3811 (void) cached_has_bits;
3812
3813 cached_has_bits = from._impl_._has_bits_[0];
3814 if (cached_has_bits & 0x000000ffu) {
3815 if (cached_has_bits & 0x00000001u) {
3816 _this->_impl_.num_ = from._impl_.num_;
3817 }
3818 if (cached_has_bits & 0x00000002u) {
3819 _this->_impl_.play_cnt_ = from._impl_.play_cnt_;
3820 }
3821 if (cached_has_bits & 0x00000004u) {
3822 _this->_impl_.mixer_ = from._impl_.mixer_;
3823 }
3824 if (cached_has_bits & 0x00000008u) {
3825 _this->_impl_.stage_ = from._impl_.stage_;
3826 }
3827 if (cached_has_bits & 0x00000010u) {
3828 _this->_impl_.flags_ = from._impl_.flags_;
3829 }
3830 if (cached_has_bits & 0x00000020u) {
3831 _this->_impl_.format_ = from._impl_.format_;
3832 }
3833 if (cached_has_bits & 0x00000040u) {
3834 _this->_impl_.img_w_ = from._impl_.img_w_;
3835 }
3836 if (cached_has_bits & 0x00000080u) {
3837 _this->_impl_.img_h_ = from._impl_.img_h_;
3838 }
3839 _this->_impl_._has_bits_[0] |= cached_has_bits;
3840 }
3841 if (cached_has_bits & 0x0000ff00u) {
3842 if (cached_has_bits & 0x00000100u) {
3843 _this->_impl_.src_x_ = from._impl_.src_x_;
3844 }
3845 if (cached_has_bits & 0x00000200u) {
3846 _this->_impl_.src_y_ = from._impl_.src_y_;
3847 }
3848 if (cached_has_bits & 0x00000400u) {
3849 _this->_impl_.src_w_ = from._impl_.src_w_;
3850 }
3851 if (cached_has_bits & 0x00000800u) {
3852 _this->_impl_.src_h_ = from._impl_.src_h_;
3853 }
3854 if (cached_has_bits & 0x00001000u) {
3855 _this->_impl_.dst_x_ = from._impl_.dst_x_;
3856 }
3857 if (cached_has_bits & 0x00002000u) {
3858 _this->_impl_.dst_y_ = from._impl_.dst_y_;
3859 }
3860 if (cached_has_bits & 0x00004000u) {
3861 _this->_impl_.dst_w_ = from._impl_.dst_w_;
3862 }
3863 if (cached_has_bits & 0x00008000u) {
3864 _this->_impl_.dst_h_ = from._impl_.dst_h_;
3865 }
3866 _this->_impl_._has_bits_[0] |= cached_has_bits;
3867 }
3868 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3869 }
3870
CopyFrom(const MdpSsppSetFtraceEvent & from)3871 void MdpSsppSetFtraceEvent::CopyFrom(const MdpSsppSetFtraceEvent& from) {
3872 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpSsppSetFtraceEvent)
3873 if (&from == this) return;
3874 Clear();
3875 MergeFrom(from);
3876 }
3877
IsInitialized() const3878 bool MdpSsppSetFtraceEvent::IsInitialized() const {
3879 return true;
3880 }
3881
InternalSwap(MdpSsppSetFtraceEvent * other)3882 void MdpSsppSetFtraceEvent::InternalSwap(MdpSsppSetFtraceEvent* other) {
3883 using std::swap;
3884 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3885 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3886 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3887 PROTOBUF_FIELD_OFFSET(MdpSsppSetFtraceEvent, _impl_.dst_h_)
3888 + sizeof(MdpSsppSetFtraceEvent::_impl_.dst_h_) // NOLINT
3889 - PROTOBUF_FIELD_OFFSET(MdpSsppSetFtraceEvent, _impl_.num_)>(
3890 reinterpret_cast<char*>(&_impl_.num_),
3891 reinterpret_cast<char*>(&other->_impl_.num_));
3892 }
3893
GetTypeName() const3894 std::string MdpSsppSetFtraceEvent::GetTypeName() const {
3895 return "perfetto.protos.MdpSsppSetFtraceEvent";
3896 }
3897
3898
3899 // ===================================================================
3900
3901 class MdpCmdReadptrDoneFtraceEvent::_Internal {
3902 public:
3903 using HasBits = decltype(std::declval<MdpCmdReadptrDoneFtraceEvent>()._impl_._has_bits_);
set_has_ctl_num(HasBits * has_bits)3904 static void set_has_ctl_num(HasBits* has_bits) {
3905 (*has_bits)[0] |= 1u;
3906 }
set_has_koff_cnt(HasBits * has_bits)3907 static void set_has_koff_cnt(HasBits* has_bits) {
3908 (*has_bits)[0] |= 2u;
3909 }
3910 };
3911
MdpCmdReadptrDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3912 MdpCmdReadptrDoneFtraceEvent::MdpCmdReadptrDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3913 bool is_message_owned)
3914 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3915 SharedCtor(arena, is_message_owned);
3916 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
3917 }
MdpCmdReadptrDoneFtraceEvent(const MdpCmdReadptrDoneFtraceEvent & from)3918 MdpCmdReadptrDoneFtraceEvent::MdpCmdReadptrDoneFtraceEvent(const MdpCmdReadptrDoneFtraceEvent& from)
3919 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3920 MdpCmdReadptrDoneFtraceEvent* const _this = this; (void)_this;
3921 new (&_impl_) Impl_{
3922 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3923 , /*decltype(_impl_._cached_size_)*/{}
3924 , decltype(_impl_.ctl_num_){}
3925 , decltype(_impl_.koff_cnt_){}};
3926
3927 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3928 ::memcpy(&_impl_.ctl_num_, &from._impl_.ctl_num_,
3929 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.koff_cnt_) -
3930 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.koff_cnt_));
3931 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
3932 }
3933
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3934 inline void MdpCmdReadptrDoneFtraceEvent::SharedCtor(
3935 ::_pb::Arena* arena, bool is_message_owned) {
3936 (void)arena;
3937 (void)is_message_owned;
3938 new (&_impl_) Impl_{
3939 decltype(_impl_._has_bits_){}
3940 , /*decltype(_impl_._cached_size_)*/{}
3941 , decltype(_impl_.ctl_num_){0u}
3942 , decltype(_impl_.koff_cnt_){0}
3943 };
3944 }
3945
~MdpCmdReadptrDoneFtraceEvent()3946 MdpCmdReadptrDoneFtraceEvent::~MdpCmdReadptrDoneFtraceEvent() {
3947 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
3948 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3949 (void)arena;
3950 return;
3951 }
3952 SharedDtor();
3953 }
3954
SharedDtor()3955 inline void MdpCmdReadptrDoneFtraceEvent::SharedDtor() {
3956 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3957 }
3958
SetCachedSize(int size) const3959 void MdpCmdReadptrDoneFtraceEvent::SetCachedSize(int size) const {
3960 _impl_._cached_size_.Set(size);
3961 }
3962
Clear()3963 void MdpCmdReadptrDoneFtraceEvent::Clear() {
3964 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
3965 ::uint32_t cached_has_bits = 0;
3966 // Prevent compiler warnings about cached_has_bits being unused
3967 (void) cached_has_bits;
3968
3969 cached_has_bits = _impl_._has_bits_[0];
3970 if (cached_has_bits & 0x00000003u) {
3971 ::memset(&_impl_.ctl_num_, 0, static_cast<size_t>(
3972 reinterpret_cast<char*>(&_impl_.koff_cnt_) -
3973 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.koff_cnt_));
3974 }
3975 _impl_._has_bits_.Clear();
3976 _internal_metadata_.Clear<std::string>();
3977 }
3978
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3979 const char* MdpCmdReadptrDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3980 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3981 _Internal::HasBits has_bits{};
3982 while (!ctx->Done(&ptr)) {
3983 ::uint32_t tag;
3984 ptr = ::_pbi::ReadTag(ptr, &tag);
3985 switch (tag >> 3) {
3986 // optional uint32 ctl_num = 1;
3987 case 1:
3988 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3989 _Internal::set_has_ctl_num(&has_bits);
3990 _impl_.ctl_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3991 CHK_(ptr);
3992 } else {
3993 goto handle_unusual;
3994 }
3995 continue;
3996 // optional int32 koff_cnt = 2;
3997 case 2:
3998 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3999 _Internal::set_has_koff_cnt(&has_bits);
4000 _impl_.koff_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4001 CHK_(ptr);
4002 } else {
4003 goto handle_unusual;
4004 }
4005 continue;
4006 default:
4007 goto handle_unusual;
4008 } // switch
4009 handle_unusual:
4010 if ((tag == 0) || ((tag & 7) == 4)) {
4011 CHK_(ptr);
4012 ctx->SetLastTag(tag);
4013 goto message_done;
4014 }
4015 ptr = UnknownFieldParse(
4016 tag,
4017 _internal_metadata_.mutable_unknown_fields<std::string>(),
4018 ptr, ctx);
4019 CHK_(ptr != nullptr);
4020 } // while
4021 message_done:
4022 _impl_._has_bits_.Or(has_bits);
4023 return ptr;
4024 failure:
4025 ptr = nullptr;
4026 goto message_done;
4027 #undef CHK_
4028 }
4029
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4030 ::uint8_t* MdpCmdReadptrDoneFtraceEvent::_InternalSerialize(
4031 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4032 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
4033 ::uint32_t cached_has_bits = 0;
4034 (void) cached_has_bits;
4035
4036 cached_has_bits = _impl_._has_bits_[0];
4037 // optional uint32 ctl_num = 1;
4038 if (cached_has_bits & 0x00000001u) {
4039 target = stream->EnsureSpace(target);
4040 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ctl_num(), target);
4041 }
4042
4043 // optional int32 koff_cnt = 2;
4044 if (cached_has_bits & 0x00000002u) {
4045 target = stream->EnsureSpace(target);
4046 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_koff_cnt(), target);
4047 }
4048
4049 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4050 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4051 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4052 }
4053 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
4054 return target;
4055 }
4056
ByteSizeLong() const4057 size_t MdpCmdReadptrDoneFtraceEvent::ByteSizeLong() const {
4058 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
4059 size_t total_size = 0;
4060
4061 ::uint32_t cached_has_bits = 0;
4062 // Prevent compiler warnings about cached_has_bits being unused
4063 (void) cached_has_bits;
4064
4065 cached_has_bits = _impl_._has_bits_[0];
4066 if (cached_has_bits & 0x00000003u) {
4067 // optional uint32 ctl_num = 1;
4068 if (cached_has_bits & 0x00000001u) {
4069 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ctl_num());
4070 }
4071
4072 // optional int32 koff_cnt = 2;
4073 if (cached_has_bits & 0x00000002u) {
4074 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_koff_cnt());
4075 }
4076
4077 }
4078 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4079 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4080 }
4081 int cached_size = ::_pbi::ToCachedSize(total_size);
4082 SetCachedSize(cached_size);
4083 return total_size;
4084 }
4085
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4086 void MdpCmdReadptrDoneFtraceEvent::CheckTypeAndMergeFrom(
4087 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4088 MergeFrom(*::_pbi::DownCast<const MdpCmdReadptrDoneFtraceEvent*>(
4089 &from));
4090 }
4091
MergeFrom(const MdpCmdReadptrDoneFtraceEvent & from)4092 void MdpCmdReadptrDoneFtraceEvent::MergeFrom(const MdpCmdReadptrDoneFtraceEvent& from) {
4093 MdpCmdReadptrDoneFtraceEvent* const _this = this;
4094 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
4095 GOOGLE_DCHECK_NE(&from, _this);
4096 ::uint32_t cached_has_bits = 0;
4097 (void) cached_has_bits;
4098
4099 cached_has_bits = from._impl_._has_bits_[0];
4100 if (cached_has_bits & 0x00000003u) {
4101 if (cached_has_bits & 0x00000001u) {
4102 _this->_impl_.ctl_num_ = from._impl_.ctl_num_;
4103 }
4104 if (cached_has_bits & 0x00000002u) {
4105 _this->_impl_.koff_cnt_ = from._impl_.koff_cnt_;
4106 }
4107 _this->_impl_._has_bits_[0] |= cached_has_bits;
4108 }
4109 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4110 }
4111
CopyFrom(const MdpCmdReadptrDoneFtraceEvent & from)4112 void MdpCmdReadptrDoneFtraceEvent::CopyFrom(const MdpCmdReadptrDoneFtraceEvent& from) {
4113 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCmdReadptrDoneFtraceEvent)
4114 if (&from == this) return;
4115 Clear();
4116 MergeFrom(from);
4117 }
4118
IsInitialized() const4119 bool MdpCmdReadptrDoneFtraceEvent::IsInitialized() const {
4120 return true;
4121 }
4122
InternalSwap(MdpCmdReadptrDoneFtraceEvent * other)4123 void MdpCmdReadptrDoneFtraceEvent::InternalSwap(MdpCmdReadptrDoneFtraceEvent* other) {
4124 using std::swap;
4125 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4126 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4127 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4128 PROTOBUF_FIELD_OFFSET(MdpCmdReadptrDoneFtraceEvent, _impl_.koff_cnt_)
4129 + sizeof(MdpCmdReadptrDoneFtraceEvent::_impl_.koff_cnt_) // NOLINT
4130 - PROTOBUF_FIELD_OFFSET(MdpCmdReadptrDoneFtraceEvent, _impl_.ctl_num_)>(
4131 reinterpret_cast<char*>(&_impl_.ctl_num_),
4132 reinterpret_cast<char*>(&other->_impl_.ctl_num_));
4133 }
4134
GetTypeName() const4135 std::string MdpCmdReadptrDoneFtraceEvent::GetTypeName() const {
4136 return "perfetto.protos.MdpCmdReadptrDoneFtraceEvent";
4137 }
4138
4139
4140 // ===================================================================
4141
4142 class MdpMisrCrcFtraceEvent::_Internal {
4143 public:
4144 using HasBits = decltype(std::declval<MdpMisrCrcFtraceEvent>()._impl_._has_bits_);
set_has_block_id(HasBits * has_bits)4145 static void set_has_block_id(HasBits* has_bits) {
4146 (*has_bits)[0] |= 1u;
4147 }
set_has_vsync_cnt(HasBits * has_bits)4148 static void set_has_vsync_cnt(HasBits* has_bits) {
4149 (*has_bits)[0] |= 2u;
4150 }
set_has_crc(HasBits * has_bits)4151 static void set_has_crc(HasBits* has_bits) {
4152 (*has_bits)[0] |= 4u;
4153 }
4154 };
4155
MdpMisrCrcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4156 MdpMisrCrcFtraceEvent::MdpMisrCrcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4157 bool is_message_owned)
4158 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4159 SharedCtor(arena, is_message_owned);
4160 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpMisrCrcFtraceEvent)
4161 }
MdpMisrCrcFtraceEvent(const MdpMisrCrcFtraceEvent & from)4162 MdpMisrCrcFtraceEvent::MdpMisrCrcFtraceEvent(const MdpMisrCrcFtraceEvent& from)
4163 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4164 MdpMisrCrcFtraceEvent* const _this = this; (void)_this;
4165 new (&_impl_) Impl_{
4166 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4167 , /*decltype(_impl_._cached_size_)*/{}
4168 , decltype(_impl_.block_id_){}
4169 , decltype(_impl_.vsync_cnt_){}
4170 , decltype(_impl_.crc_){}};
4171
4172 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4173 ::memcpy(&_impl_.block_id_, &from._impl_.block_id_,
4174 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.crc_) -
4175 reinterpret_cast<char*>(&_impl_.block_id_)) + sizeof(_impl_.crc_));
4176 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpMisrCrcFtraceEvent)
4177 }
4178
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4179 inline void MdpMisrCrcFtraceEvent::SharedCtor(
4180 ::_pb::Arena* arena, bool is_message_owned) {
4181 (void)arena;
4182 (void)is_message_owned;
4183 new (&_impl_) Impl_{
4184 decltype(_impl_._has_bits_){}
4185 , /*decltype(_impl_._cached_size_)*/{}
4186 , decltype(_impl_.block_id_){0u}
4187 , decltype(_impl_.vsync_cnt_){0u}
4188 , decltype(_impl_.crc_){0u}
4189 };
4190 }
4191
~MdpMisrCrcFtraceEvent()4192 MdpMisrCrcFtraceEvent::~MdpMisrCrcFtraceEvent() {
4193 // @@protoc_insertion_point(destructor:perfetto.protos.MdpMisrCrcFtraceEvent)
4194 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4195 (void)arena;
4196 return;
4197 }
4198 SharedDtor();
4199 }
4200
SharedDtor()4201 inline void MdpMisrCrcFtraceEvent::SharedDtor() {
4202 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4203 }
4204
SetCachedSize(int size) const4205 void MdpMisrCrcFtraceEvent::SetCachedSize(int size) const {
4206 _impl_._cached_size_.Set(size);
4207 }
4208
Clear()4209 void MdpMisrCrcFtraceEvent::Clear() {
4210 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpMisrCrcFtraceEvent)
4211 ::uint32_t cached_has_bits = 0;
4212 // Prevent compiler warnings about cached_has_bits being unused
4213 (void) cached_has_bits;
4214
4215 cached_has_bits = _impl_._has_bits_[0];
4216 if (cached_has_bits & 0x00000007u) {
4217 ::memset(&_impl_.block_id_, 0, static_cast<size_t>(
4218 reinterpret_cast<char*>(&_impl_.crc_) -
4219 reinterpret_cast<char*>(&_impl_.block_id_)) + sizeof(_impl_.crc_));
4220 }
4221 _impl_._has_bits_.Clear();
4222 _internal_metadata_.Clear<std::string>();
4223 }
4224
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4225 const char* MdpMisrCrcFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4226 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4227 _Internal::HasBits has_bits{};
4228 while (!ctx->Done(&ptr)) {
4229 ::uint32_t tag;
4230 ptr = ::_pbi::ReadTag(ptr, &tag);
4231 switch (tag >> 3) {
4232 // optional uint32 block_id = 1;
4233 case 1:
4234 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4235 _Internal::set_has_block_id(&has_bits);
4236 _impl_.block_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4237 CHK_(ptr);
4238 } else {
4239 goto handle_unusual;
4240 }
4241 continue;
4242 // optional uint32 vsync_cnt = 2;
4243 case 2:
4244 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4245 _Internal::set_has_vsync_cnt(&has_bits);
4246 _impl_.vsync_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4247 CHK_(ptr);
4248 } else {
4249 goto handle_unusual;
4250 }
4251 continue;
4252 // optional uint32 crc = 3;
4253 case 3:
4254 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4255 _Internal::set_has_crc(&has_bits);
4256 _impl_.crc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4257 CHK_(ptr);
4258 } else {
4259 goto handle_unusual;
4260 }
4261 continue;
4262 default:
4263 goto handle_unusual;
4264 } // switch
4265 handle_unusual:
4266 if ((tag == 0) || ((tag & 7) == 4)) {
4267 CHK_(ptr);
4268 ctx->SetLastTag(tag);
4269 goto message_done;
4270 }
4271 ptr = UnknownFieldParse(
4272 tag,
4273 _internal_metadata_.mutable_unknown_fields<std::string>(),
4274 ptr, ctx);
4275 CHK_(ptr != nullptr);
4276 } // while
4277 message_done:
4278 _impl_._has_bits_.Or(has_bits);
4279 return ptr;
4280 failure:
4281 ptr = nullptr;
4282 goto message_done;
4283 #undef CHK_
4284 }
4285
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4286 ::uint8_t* MdpMisrCrcFtraceEvent::_InternalSerialize(
4287 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4288 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpMisrCrcFtraceEvent)
4289 ::uint32_t cached_has_bits = 0;
4290 (void) cached_has_bits;
4291
4292 cached_has_bits = _impl_._has_bits_[0];
4293 // optional uint32 block_id = 1;
4294 if (cached_has_bits & 0x00000001u) {
4295 target = stream->EnsureSpace(target);
4296 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_block_id(), target);
4297 }
4298
4299 // optional uint32 vsync_cnt = 2;
4300 if (cached_has_bits & 0x00000002u) {
4301 target = stream->EnsureSpace(target);
4302 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_vsync_cnt(), target);
4303 }
4304
4305 // optional uint32 crc = 3;
4306 if (cached_has_bits & 0x00000004u) {
4307 target = stream->EnsureSpace(target);
4308 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_crc(), target);
4309 }
4310
4311 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4312 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4313 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4314 }
4315 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpMisrCrcFtraceEvent)
4316 return target;
4317 }
4318
ByteSizeLong() const4319 size_t MdpMisrCrcFtraceEvent::ByteSizeLong() const {
4320 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpMisrCrcFtraceEvent)
4321 size_t total_size = 0;
4322
4323 ::uint32_t cached_has_bits = 0;
4324 // Prevent compiler warnings about cached_has_bits being unused
4325 (void) cached_has_bits;
4326
4327 cached_has_bits = _impl_._has_bits_[0];
4328 if (cached_has_bits & 0x00000007u) {
4329 // optional uint32 block_id = 1;
4330 if (cached_has_bits & 0x00000001u) {
4331 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_block_id());
4332 }
4333
4334 // optional uint32 vsync_cnt = 2;
4335 if (cached_has_bits & 0x00000002u) {
4336 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_vsync_cnt());
4337 }
4338
4339 // optional uint32 crc = 3;
4340 if (cached_has_bits & 0x00000004u) {
4341 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_crc());
4342 }
4343
4344 }
4345 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4346 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4347 }
4348 int cached_size = ::_pbi::ToCachedSize(total_size);
4349 SetCachedSize(cached_size);
4350 return total_size;
4351 }
4352
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4353 void MdpMisrCrcFtraceEvent::CheckTypeAndMergeFrom(
4354 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4355 MergeFrom(*::_pbi::DownCast<const MdpMisrCrcFtraceEvent*>(
4356 &from));
4357 }
4358
MergeFrom(const MdpMisrCrcFtraceEvent & from)4359 void MdpMisrCrcFtraceEvent::MergeFrom(const MdpMisrCrcFtraceEvent& from) {
4360 MdpMisrCrcFtraceEvent* const _this = this;
4361 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpMisrCrcFtraceEvent)
4362 GOOGLE_DCHECK_NE(&from, _this);
4363 ::uint32_t cached_has_bits = 0;
4364 (void) cached_has_bits;
4365
4366 cached_has_bits = from._impl_._has_bits_[0];
4367 if (cached_has_bits & 0x00000007u) {
4368 if (cached_has_bits & 0x00000001u) {
4369 _this->_impl_.block_id_ = from._impl_.block_id_;
4370 }
4371 if (cached_has_bits & 0x00000002u) {
4372 _this->_impl_.vsync_cnt_ = from._impl_.vsync_cnt_;
4373 }
4374 if (cached_has_bits & 0x00000004u) {
4375 _this->_impl_.crc_ = from._impl_.crc_;
4376 }
4377 _this->_impl_._has_bits_[0] |= cached_has_bits;
4378 }
4379 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4380 }
4381
CopyFrom(const MdpMisrCrcFtraceEvent & from)4382 void MdpMisrCrcFtraceEvent::CopyFrom(const MdpMisrCrcFtraceEvent& from) {
4383 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpMisrCrcFtraceEvent)
4384 if (&from == this) return;
4385 Clear();
4386 MergeFrom(from);
4387 }
4388
IsInitialized() const4389 bool MdpMisrCrcFtraceEvent::IsInitialized() const {
4390 return true;
4391 }
4392
InternalSwap(MdpMisrCrcFtraceEvent * other)4393 void MdpMisrCrcFtraceEvent::InternalSwap(MdpMisrCrcFtraceEvent* other) {
4394 using std::swap;
4395 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4396 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4397 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4398 PROTOBUF_FIELD_OFFSET(MdpMisrCrcFtraceEvent, _impl_.crc_)
4399 + sizeof(MdpMisrCrcFtraceEvent::_impl_.crc_) // NOLINT
4400 - PROTOBUF_FIELD_OFFSET(MdpMisrCrcFtraceEvent, _impl_.block_id_)>(
4401 reinterpret_cast<char*>(&_impl_.block_id_),
4402 reinterpret_cast<char*>(&other->_impl_.block_id_));
4403 }
4404
GetTypeName() const4405 std::string MdpMisrCrcFtraceEvent::GetTypeName() const {
4406 return "perfetto.protos.MdpMisrCrcFtraceEvent";
4407 }
4408
4409
4410 // ===================================================================
4411
4412 class MdpPerfSetQosLutsFtraceEvent::_Internal {
4413 public:
4414 using HasBits = decltype(std::declval<MdpPerfSetQosLutsFtraceEvent>()._impl_._has_bits_);
set_has_pnum(HasBits * has_bits)4415 static void set_has_pnum(HasBits* has_bits) {
4416 (*has_bits)[0] |= 1u;
4417 }
set_has_fmt(HasBits * has_bits)4418 static void set_has_fmt(HasBits* has_bits) {
4419 (*has_bits)[0] |= 2u;
4420 }
set_has_intf(HasBits * has_bits)4421 static void set_has_intf(HasBits* has_bits) {
4422 (*has_bits)[0] |= 4u;
4423 }
set_has_rot(HasBits * has_bits)4424 static void set_has_rot(HasBits* has_bits) {
4425 (*has_bits)[0] |= 8u;
4426 }
set_has_fl(HasBits * has_bits)4427 static void set_has_fl(HasBits* has_bits) {
4428 (*has_bits)[0] |= 16u;
4429 }
set_has_lut(HasBits * has_bits)4430 static void set_has_lut(HasBits* has_bits) {
4431 (*has_bits)[0] |= 32u;
4432 }
set_has_linear(HasBits * has_bits)4433 static void set_has_linear(HasBits* has_bits) {
4434 (*has_bits)[0] |= 64u;
4435 }
4436 };
4437
MdpPerfSetQosLutsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4438 MdpPerfSetQosLutsFtraceEvent::MdpPerfSetQosLutsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4439 bool is_message_owned)
4440 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4441 SharedCtor(arena, is_message_owned);
4442 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4443 }
MdpPerfSetQosLutsFtraceEvent(const MdpPerfSetQosLutsFtraceEvent & from)4444 MdpPerfSetQosLutsFtraceEvent::MdpPerfSetQosLutsFtraceEvent(const MdpPerfSetQosLutsFtraceEvent& from)
4445 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4446 MdpPerfSetQosLutsFtraceEvent* const _this = this; (void)_this;
4447 new (&_impl_) Impl_{
4448 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4449 , /*decltype(_impl_._cached_size_)*/{}
4450 , decltype(_impl_.pnum_){}
4451 , decltype(_impl_.fmt_){}
4452 , decltype(_impl_.intf_){}
4453 , decltype(_impl_.rot_){}
4454 , decltype(_impl_.fl_){}
4455 , decltype(_impl_.lut_){}
4456 , decltype(_impl_.linear_){}};
4457
4458 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4459 ::memcpy(&_impl_.pnum_, &from._impl_.pnum_,
4460 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.linear_) -
4461 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.linear_));
4462 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4463 }
4464
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4465 inline void MdpPerfSetQosLutsFtraceEvent::SharedCtor(
4466 ::_pb::Arena* arena, bool is_message_owned) {
4467 (void)arena;
4468 (void)is_message_owned;
4469 new (&_impl_) Impl_{
4470 decltype(_impl_._has_bits_){}
4471 , /*decltype(_impl_._cached_size_)*/{}
4472 , decltype(_impl_.pnum_){0u}
4473 , decltype(_impl_.fmt_){0u}
4474 , decltype(_impl_.intf_){0u}
4475 , decltype(_impl_.rot_){0u}
4476 , decltype(_impl_.fl_){0u}
4477 , decltype(_impl_.lut_){0u}
4478 , decltype(_impl_.linear_){0u}
4479 };
4480 }
4481
~MdpPerfSetQosLutsFtraceEvent()4482 MdpPerfSetQosLutsFtraceEvent::~MdpPerfSetQosLutsFtraceEvent() {
4483 // @@protoc_insertion_point(destructor:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4484 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4485 (void)arena;
4486 return;
4487 }
4488 SharedDtor();
4489 }
4490
SharedDtor()4491 inline void MdpPerfSetQosLutsFtraceEvent::SharedDtor() {
4492 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4493 }
4494
SetCachedSize(int size) const4495 void MdpPerfSetQosLutsFtraceEvent::SetCachedSize(int size) const {
4496 _impl_._cached_size_.Set(size);
4497 }
4498
Clear()4499 void MdpPerfSetQosLutsFtraceEvent::Clear() {
4500 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4501 ::uint32_t cached_has_bits = 0;
4502 // Prevent compiler warnings about cached_has_bits being unused
4503 (void) cached_has_bits;
4504
4505 cached_has_bits = _impl_._has_bits_[0];
4506 if (cached_has_bits & 0x0000007fu) {
4507 ::memset(&_impl_.pnum_, 0, static_cast<size_t>(
4508 reinterpret_cast<char*>(&_impl_.linear_) -
4509 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.linear_));
4510 }
4511 _impl_._has_bits_.Clear();
4512 _internal_metadata_.Clear<std::string>();
4513 }
4514
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4515 const char* MdpPerfSetQosLutsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4516 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4517 _Internal::HasBits has_bits{};
4518 while (!ctx->Done(&ptr)) {
4519 ::uint32_t tag;
4520 ptr = ::_pbi::ReadTag(ptr, &tag);
4521 switch (tag >> 3) {
4522 // optional uint32 pnum = 1;
4523 case 1:
4524 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4525 _Internal::set_has_pnum(&has_bits);
4526 _impl_.pnum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4527 CHK_(ptr);
4528 } else {
4529 goto handle_unusual;
4530 }
4531 continue;
4532 // optional uint32 fmt = 2;
4533 case 2:
4534 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4535 _Internal::set_has_fmt(&has_bits);
4536 _impl_.fmt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4537 CHK_(ptr);
4538 } else {
4539 goto handle_unusual;
4540 }
4541 continue;
4542 // optional uint32 intf = 3;
4543 case 3:
4544 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4545 _Internal::set_has_intf(&has_bits);
4546 _impl_.intf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4547 CHK_(ptr);
4548 } else {
4549 goto handle_unusual;
4550 }
4551 continue;
4552 // optional uint32 rot = 4;
4553 case 4:
4554 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4555 _Internal::set_has_rot(&has_bits);
4556 _impl_.rot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4557 CHK_(ptr);
4558 } else {
4559 goto handle_unusual;
4560 }
4561 continue;
4562 // optional uint32 fl = 5;
4563 case 5:
4564 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
4565 _Internal::set_has_fl(&has_bits);
4566 _impl_.fl_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4567 CHK_(ptr);
4568 } else {
4569 goto handle_unusual;
4570 }
4571 continue;
4572 // optional uint32 lut = 6;
4573 case 6:
4574 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
4575 _Internal::set_has_lut(&has_bits);
4576 _impl_.lut_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4577 CHK_(ptr);
4578 } else {
4579 goto handle_unusual;
4580 }
4581 continue;
4582 // optional uint32 linear = 7;
4583 case 7:
4584 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
4585 _Internal::set_has_linear(&has_bits);
4586 _impl_.linear_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4587 CHK_(ptr);
4588 } else {
4589 goto handle_unusual;
4590 }
4591 continue;
4592 default:
4593 goto handle_unusual;
4594 } // switch
4595 handle_unusual:
4596 if ((tag == 0) || ((tag & 7) == 4)) {
4597 CHK_(ptr);
4598 ctx->SetLastTag(tag);
4599 goto message_done;
4600 }
4601 ptr = UnknownFieldParse(
4602 tag,
4603 _internal_metadata_.mutable_unknown_fields<std::string>(),
4604 ptr, ctx);
4605 CHK_(ptr != nullptr);
4606 } // while
4607 message_done:
4608 _impl_._has_bits_.Or(has_bits);
4609 return ptr;
4610 failure:
4611 ptr = nullptr;
4612 goto message_done;
4613 #undef CHK_
4614 }
4615
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4616 ::uint8_t* MdpPerfSetQosLutsFtraceEvent::_InternalSerialize(
4617 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4618 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4619 ::uint32_t cached_has_bits = 0;
4620 (void) cached_has_bits;
4621
4622 cached_has_bits = _impl_._has_bits_[0];
4623 // optional uint32 pnum = 1;
4624 if (cached_has_bits & 0x00000001u) {
4625 target = stream->EnsureSpace(target);
4626 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pnum(), target);
4627 }
4628
4629 // optional uint32 fmt = 2;
4630 if (cached_has_bits & 0x00000002u) {
4631 target = stream->EnsureSpace(target);
4632 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_fmt(), target);
4633 }
4634
4635 // optional uint32 intf = 3;
4636 if (cached_has_bits & 0x00000004u) {
4637 target = stream->EnsureSpace(target);
4638 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_intf(), target);
4639 }
4640
4641 // optional uint32 rot = 4;
4642 if (cached_has_bits & 0x00000008u) {
4643 target = stream->EnsureSpace(target);
4644 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_rot(), target);
4645 }
4646
4647 // optional uint32 fl = 5;
4648 if (cached_has_bits & 0x00000010u) {
4649 target = stream->EnsureSpace(target);
4650 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_fl(), target);
4651 }
4652
4653 // optional uint32 lut = 6;
4654 if (cached_has_bits & 0x00000020u) {
4655 target = stream->EnsureSpace(target);
4656 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_lut(), target);
4657 }
4658
4659 // optional uint32 linear = 7;
4660 if (cached_has_bits & 0x00000040u) {
4661 target = stream->EnsureSpace(target);
4662 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_linear(), target);
4663 }
4664
4665 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4666 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4667 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4668 }
4669 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4670 return target;
4671 }
4672
ByteSizeLong() const4673 size_t MdpPerfSetQosLutsFtraceEvent::ByteSizeLong() const {
4674 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4675 size_t total_size = 0;
4676
4677 ::uint32_t cached_has_bits = 0;
4678 // Prevent compiler warnings about cached_has_bits being unused
4679 (void) cached_has_bits;
4680
4681 cached_has_bits = _impl_._has_bits_[0];
4682 if (cached_has_bits & 0x0000007fu) {
4683 // optional uint32 pnum = 1;
4684 if (cached_has_bits & 0x00000001u) {
4685 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pnum());
4686 }
4687
4688 // optional uint32 fmt = 2;
4689 if (cached_has_bits & 0x00000002u) {
4690 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_fmt());
4691 }
4692
4693 // optional uint32 intf = 3;
4694 if (cached_has_bits & 0x00000004u) {
4695 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_intf());
4696 }
4697
4698 // optional uint32 rot = 4;
4699 if (cached_has_bits & 0x00000008u) {
4700 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rot());
4701 }
4702
4703 // optional uint32 fl = 5;
4704 if (cached_has_bits & 0x00000010u) {
4705 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_fl());
4706 }
4707
4708 // optional uint32 lut = 6;
4709 if (cached_has_bits & 0x00000020u) {
4710 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_lut());
4711 }
4712
4713 // optional uint32 linear = 7;
4714 if (cached_has_bits & 0x00000040u) {
4715 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_linear());
4716 }
4717
4718 }
4719 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4720 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4721 }
4722 int cached_size = ::_pbi::ToCachedSize(total_size);
4723 SetCachedSize(cached_size);
4724 return total_size;
4725 }
4726
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4727 void MdpPerfSetQosLutsFtraceEvent::CheckTypeAndMergeFrom(
4728 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4729 MergeFrom(*::_pbi::DownCast<const MdpPerfSetQosLutsFtraceEvent*>(
4730 &from));
4731 }
4732
MergeFrom(const MdpPerfSetQosLutsFtraceEvent & from)4733 void MdpPerfSetQosLutsFtraceEvent::MergeFrom(const MdpPerfSetQosLutsFtraceEvent& from) {
4734 MdpPerfSetQosLutsFtraceEvent* const _this = this;
4735 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4736 GOOGLE_DCHECK_NE(&from, _this);
4737 ::uint32_t cached_has_bits = 0;
4738 (void) cached_has_bits;
4739
4740 cached_has_bits = from._impl_._has_bits_[0];
4741 if (cached_has_bits & 0x0000007fu) {
4742 if (cached_has_bits & 0x00000001u) {
4743 _this->_impl_.pnum_ = from._impl_.pnum_;
4744 }
4745 if (cached_has_bits & 0x00000002u) {
4746 _this->_impl_.fmt_ = from._impl_.fmt_;
4747 }
4748 if (cached_has_bits & 0x00000004u) {
4749 _this->_impl_.intf_ = from._impl_.intf_;
4750 }
4751 if (cached_has_bits & 0x00000008u) {
4752 _this->_impl_.rot_ = from._impl_.rot_;
4753 }
4754 if (cached_has_bits & 0x00000010u) {
4755 _this->_impl_.fl_ = from._impl_.fl_;
4756 }
4757 if (cached_has_bits & 0x00000020u) {
4758 _this->_impl_.lut_ = from._impl_.lut_;
4759 }
4760 if (cached_has_bits & 0x00000040u) {
4761 _this->_impl_.linear_ = from._impl_.linear_;
4762 }
4763 _this->_impl_._has_bits_[0] |= cached_has_bits;
4764 }
4765 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4766 }
4767
CopyFrom(const MdpPerfSetQosLutsFtraceEvent & from)4768 void MdpPerfSetQosLutsFtraceEvent::CopyFrom(const MdpPerfSetQosLutsFtraceEvent& from) {
4769 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpPerfSetQosLutsFtraceEvent)
4770 if (&from == this) return;
4771 Clear();
4772 MergeFrom(from);
4773 }
4774
IsInitialized() const4775 bool MdpPerfSetQosLutsFtraceEvent::IsInitialized() const {
4776 return true;
4777 }
4778
InternalSwap(MdpPerfSetQosLutsFtraceEvent * other)4779 void MdpPerfSetQosLutsFtraceEvent::InternalSwap(MdpPerfSetQosLutsFtraceEvent* other) {
4780 using std::swap;
4781 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4782 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4783 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4784 PROTOBUF_FIELD_OFFSET(MdpPerfSetQosLutsFtraceEvent, _impl_.linear_)
4785 + sizeof(MdpPerfSetQosLutsFtraceEvent::_impl_.linear_) // NOLINT
4786 - PROTOBUF_FIELD_OFFSET(MdpPerfSetQosLutsFtraceEvent, _impl_.pnum_)>(
4787 reinterpret_cast<char*>(&_impl_.pnum_),
4788 reinterpret_cast<char*>(&other->_impl_.pnum_));
4789 }
4790
GetTypeName() const4791 std::string MdpPerfSetQosLutsFtraceEvent::GetTypeName() const {
4792 return "perfetto.protos.MdpPerfSetQosLutsFtraceEvent";
4793 }
4794
4795
4796 // ===================================================================
4797
4798 class MdpTraceCounterFtraceEvent::_Internal {
4799 public:
4800 using HasBits = decltype(std::declval<MdpTraceCounterFtraceEvent>()._impl_._has_bits_);
set_has_pid(HasBits * has_bits)4801 static void set_has_pid(HasBits* has_bits) {
4802 (*has_bits)[0] |= 2u;
4803 }
set_has_counter_name(HasBits * has_bits)4804 static void set_has_counter_name(HasBits* has_bits) {
4805 (*has_bits)[0] |= 1u;
4806 }
set_has_value(HasBits * has_bits)4807 static void set_has_value(HasBits* has_bits) {
4808 (*has_bits)[0] |= 4u;
4809 }
4810 };
4811
MdpTraceCounterFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4812 MdpTraceCounterFtraceEvent::MdpTraceCounterFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4813 bool is_message_owned)
4814 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4815 SharedCtor(arena, is_message_owned);
4816 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpTraceCounterFtraceEvent)
4817 }
MdpTraceCounterFtraceEvent(const MdpTraceCounterFtraceEvent & from)4818 MdpTraceCounterFtraceEvent::MdpTraceCounterFtraceEvent(const MdpTraceCounterFtraceEvent& from)
4819 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4820 MdpTraceCounterFtraceEvent* const _this = this; (void)_this;
4821 new (&_impl_) Impl_{
4822 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4823 , /*decltype(_impl_._cached_size_)*/{}
4824 , decltype(_impl_.counter_name_){}
4825 , decltype(_impl_.pid_){}
4826 , decltype(_impl_.value_){}};
4827
4828 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4829 _impl_.counter_name_.InitDefault();
4830 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4831 _impl_.counter_name_.Set("", GetArenaForAllocation());
4832 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4833 if (from._internal_has_counter_name()) {
4834 _this->_impl_.counter_name_.Set(from._internal_counter_name(),
4835 _this->GetArenaForAllocation());
4836 }
4837 ::memcpy(&_impl_.pid_, &from._impl_.pid_,
4838 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.value_) -
4839 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.value_));
4840 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpTraceCounterFtraceEvent)
4841 }
4842
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4843 inline void MdpTraceCounterFtraceEvent::SharedCtor(
4844 ::_pb::Arena* arena, bool is_message_owned) {
4845 (void)arena;
4846 (void)is_message_owned;
4847 new (&_impl_) Impl_{
4848 decltype(_impl_._has_bits_){}
4849 , /*decltype(_impl_._cached_size_)*/{}
4850 , decltype(_impl_.counter_name_){}
4851 , decltype(_impl_.pid_){0}
4852 , decltype(_impl_.value_){0}
4853 };
4854 _impl_.counter_name_.InitDefault();
4855 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
4856 _impl_.counter_name_.Set("", GetArenaForAllocation());
4857 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
4858 }
4859
~MdpTraceCounterFtraceEvent()4860 MdpTraceCounterFtraceEvent::~MdpTraceCounterFtraceEvent() {
4861 // @@protoc_insertion_point(destructor:perfetto.protos.MdpTraceCounterFtraceEvent)
4862 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4863 (void)arena;
4864 return;
4865 }
4866 SharedDtor();
4867 }
4868
SharedDtor()4869 inline void MdpTraceCounterFtraceEvent::SharedDtor() {
4870 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4871 _impl_.counter_name_.Destroy();
4872 }
4873
SetCachedSize(int size) const4874 void MdpTraceCounterFtraceEvent::SetCachedSize(int size) const {
4875 _impl_._cached_size_.Set(size);
4876 }
4877
Clear()4878 void MdpTraceCounterFtraceEvent::Clear() {
4879 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpTraceCounterFtraceEvent)
4880 ::uint32_t cached_has_bits = 0;
4881 // Prevent compiler warnings about cached_has_bits being unused
4882 (void) cached_has_bits;
4883
4884 cached_has_bits = _impl_._has_bits_[0];
4885 if (cached_has_bits & 0x00000001u) {
4886 _impl_.counter_name_.ClearNonDefaultToEmpty();
4887 }
4888 if (cached_has_bits & 0x00000006u) {
4889 ::memset(&_impl_.pid_, 0, static_cast<size_t>(
4890 reinterpret_cast<char*>(&_impl_.value_) -
4891 reinterpret_cast<char*>(&_impl_.pid_)) + sizeof(_impl_.value_));
4892 }
4893 _impl_._has_bits_.Clear();
4894 _internal_metadata_.Clear<std::string>();
4895 }
4896
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4897 const char* MdpTraceCounterFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4898 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4899 _Internal::HasBits has_bits{};
4900 while (!ctx->Done(&ptr)) {
4901 ::uint32_t tag;
4902 ptr = ::_pbi::ReadTag(ptr, &tag);
4903 switch (tag >> 3) {
4904 // optional int32 pid = 1;
4905 case 1:
4906 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4907 _Internal::set_has_pid(&has_bits);
4908 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4909 CHK_(ptr);
4910 } else {
4911 goto handle_unusual;
4912 }
4913 continue;
4914 // optional string counter_name = 2;
4915 case 2:
4916 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
4917 auto str = _internal_mutable_counter_name();
4918 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
4919 CHK_(ptr);
4920 } else {
4921 goto handle_unusual;
4922 }
4923 continue;
4924 // optional int32 value = 3;
4925 case 3:
4926 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4927 _Internal::set_has_value(&has_bits);
4928 _impl_.value_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4929 CHK_(ptr);
4930 } else {
4931 goto handle_unusual;
4932 }
4933 continue;
4934 default:
4935 goto handle_unusual;
4936 } // switch
4937 handle_unusual:
4938 if ((tag == 0) || ((tag & 7) == 4)) {
4939 CHK_(ptr);
4940 ctx->SetLastTag(tag);
4941 goto message_done;
4942 }
4943 ptr = UnknownFieldParse(
4944 tag,
4945 _internal_metadata_.mutable_unknown_fields<std::string>(),
4946 ptr, ctx);
4947 CHK_(ptr != nullptr);
4948 } // while
4949 message_done:
4950 _impl_._has_bits_.Or(has_bits);
4951 return ptr;
4952 failure:
4953 ptr = nullptr;
4954 goto message_done;
4955 #undef CHK_
4956 }
4957
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4958 ::uint8_t* MdpTraceCounterFtraceEvent::_InternalSerialize(
4959 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4960 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpTraceCounterFtraceEvent)
4961 ::uint32_t cached_has_bits = 0;
4962 (void) cached_has_bits;
4963
4964 cached_has_bits = _impl_._has_bits_[0];
4965 // optional int32 pid = 1;
4966 if (cached_has_bits & 0x00000002u) {
4967 target = stream->EnsureSpace(target);
4968 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_pid(), target);
4969 }
4970
4971 // optional string counter_name = 2;
4972 if (cached_has_bits & 0x00000001u) {
4973 target = stream->WriteStringMaybeAliased(
4974 2, this->_internal_counter_name(), target);
4975 }
4976
4977 // optional int32 value = 3;
4978 if (cached_has_bits & 0x00000004u) {
4979 target = stream->EnsureSpace(target);
4980 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_value(), target);
4981 }
4982
4983 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4984 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4985 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4986 }
4987 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpTraceCounterFtraceEvent)
4988 return target;
4989 }
4990
ByteSizeLong() const4991 size_t MdpTraceCounterFtraceEvent::ByteSizeLong() const {
4992 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpTraceCounterFtraceEvent)
4993 size_t total_size = 0;
4994
4995 ::uint32_t cached_has_bits = 0;
4996 // Prevent compiler warnings about cached_has_bits being unused
4997 (void) cached_has_bits;
4998
4999 cached_has_bits = _impl_._has_bits_[0];
5000 if (cached_has_bits & 0x00000007u) {
5001 // optional string counter_name = 2;
5002 if (cached_has_bits & 0x00000001u) {
5003 total_size += 1 +
5004 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
5005 this->_internal_counter_name());
5006 }
5007
5008 // optional int32 pid = 1;
5009 if (cached_has_bits & 0x00000002u) {
5010 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
5011 }
5012
5013 // optional int32 value = 3;
5014 if (cached_has_bits & 0x00000004u) {
5015 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_value());
5016 }
5017
5018 }
5019 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5020 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5021 }
5022 int cached_size = ::_pbi::ToCachedSize(total_size);
5023 SetCachedSize(cached_size);
5024 return total_size;
5025 }
5026
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5027 void MdpTraceCounterFtraceEvent::CheckTypeAndMergeFrom(
5028 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5029 MergeFrom(*::_pbi::DownCast<const MdpTraceCounterFtraceEvent*>(
5030 &from));
5031 }
5032
MergeFrom(const MdpTraceCounterFtraceEvent & from)5033 void MdpTraceCounterFtraceEvent::MergeFrom(const MdpTraceCounterFtraceEvent& from) {
5034 MdpTraceCounterFtraceEvent* const _this = this;
5035 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpTraceCounterFtraceEvent)
5036 GOOGLE_DCHECK_NE(&from, _this);
5037 ::uint32_t cached_has_bits = 0;
5038 (void) cached_has_bits;
5039
5040 cached_has_bits = from._impl_._has_bits_[0];
5041 if (cached_has_bits & 0x00000007u) {
5042 if (cached_has_bits & 0x00000001u) {
5043 _this->_internal_set_counter_name(from._internal_counter_name());
5044 }
5045 if (cached_has_bits & 0x00000002u) {
5046 _this->_impl_.pid_ = from._impl_.pid_;
5047 }
5048 if (cached_has_bits & 0x00000004u) {
5049 _this->_impl_.value_ = from._impl_.value_;
5050 }
5051 _this->_impl_._has_bits_[0] |= cached_has_bits;
5052 }
5053 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5054 }
5055
CopyFrom(const MdpTraceCounterFtraceEvent & from)5056 void MdpTraceCounterFtraceEvent::CopyFrom(const MdpTraceCounterFtraceEvent& from) {
5057 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpTraceCounterFtraceEvent)
5058 if (&from == this) return;
5059 Clear();
5060 MergeFrom(from);
5061 }
5062
IsInitialized() const5063 bool MdpTraceCounterFtraceEvent::IsInitialized() const {
5064 return true;
5065 }
5066
InternalSwap(MdpTraceCounterFtraceEvent * other)5067 void MdpTraceCounterFtraceEvent::InternalSwap(MdpTraceCounterFtraceEvent* other) {
5068 using std::swap;
5069 auto* lhs_arena = GetArenaForAllocation();
5070 auto* rhs_arena = other->GetArenaForAllocation();
5071 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5072 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5073 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
5074 &_impl_.counter_name_, lhs_arena,
5075 &other->_impl_.counter_name_, rhs_arena
5076 );
5077 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5078 PROTOBUF_FIELD_OFFSET(MdpTraceCounterFtraceEvent, _impl_.value_)
5079 + sizeof(MdpTraceCounterFtraceEvent::_impl_.value_) // NOLINT
5080 - PROTOBUF_FIELD_OFFSET(MdpTraceCounterFtraceEvent, _impl_.pid_)>(
5081 reinterpret_cast<char*>(&_impl_.pid_),
5082 reinterpret_cast<char*>(&other->_impl_.pid_));
5083 }
5084
GetTypeName() const5085 std::string MdpTraceCounterFtraceEvent::GetTypeName() const {
5086 return "perfetto.protos.MdpTraceCounterFtraceEvent";
5087 }
5088
5089
5090 // ===================================================================
5091
5092 class MdpCmdReleaseBwFtraceEvent::_Internal {
5093 public:
5094 using HasBits = decltype(std::declval<MdpCmdReleaseBwFtraceEvent>()._impl_._has_bits_);
set_has_ctl_num(HasBits * has_bits)5095 static void set_has_ctl_num(HasBits* has_bits) {
5096 (*has_bits)[0] |= 1u;
5097 }
5098 };
5099
MdpCmdReleaseBwFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5100 MdpCmdReleaseBwFtraceEvent::MdpCmdReleaseBwFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5101 bool is_message_owned)
5102 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5103 SharedCtor(arena, is_message_owned);
5104 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5105 }
MdpCmdReleaseBwFtraceEvent(const MdpCmdReleaseBwFtraceEvent & from)5106 MdpCmdReleaseBwFtraceEvent::MdpCmdReleaseBwFtraceEvent(const MdpCmdReleaseBwFtraceEvent& from)
5107 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5108 MdpCmdReleaseBwFtraceEvent* const _this = this; (void)_this;
5109 new (&_impl_) Impl_{
5110 decltype(_impl_._has_bits_){from._impl_._has_bits_}
5111 , /*decltype(_impl_._cached_size_)*/{}
5112 , decltype(_impl_.ctl_num_){}};
5113
5114 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5115 _this->_impl_.ctl_num_ = from._impl_.ctl_num_;
5116 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5117 }
5118
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5119 inline void MdpCmdReleaseBwFtraceEvent::SharedCtor(
5120 ::_pb::Arena* arena, bool is_message_owned) {
5121 (void)arena;
5122 (void)is_message_owned;
5123 new (&_impl_) Impl_{
5124 decltype(_impl_._has_bits_){}
5125 , /*decltype(_impl_._cached_size_)*/{}
5126 , decltype(_impl_.ctl_num_){0u}
5127 };
5128 }
5129
~MdpCmdReleaseBwFtraceEvent()5130 MdpCmdReleaseBwFtraceEvent::~MdpCmdReleaseBwFtraceEvent() {
5131 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5132 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5133 (void)arena;
5134 return;
5135 }
5136 SharedDtor();
5137 }
5138
SharedDtor()5139 inline void MdpCmdReleaseBwFtraceEvent::SharedDtor() {
5140 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5141 }
5142
SetCachedSize(int size) const5143 void MdpCmdReleaseBwFtraceEvent::SetCachedSize(int size) const {
5144 _impl_._cached_size_.Set(size);
5145 }
5146
Clear()5147 void MdpCmdReleaseBwFtraceEvent::Clear() {
5148 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5149 ::uint32_t cached_has_bits = 0;
5150 // Prevent compiler warnings about cached_has_bits being unused
5151 (void) cached_has_bits;
5152
5153 _impl_.ctl_num_ = 0u;
5154 _impl_._has_bits_.Clear();
5155 _internal_metadata_.Clear<std::string>();
5156 }
5157
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5158 const char* MdpCmdReleaseBwFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5159 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5160 _Internal::HasBits has_bits{};
5161 while (!ctx->Done(&ptr)) {
5162 ::uint32_t tag;
5163 ptr = ::_pbi::ReadTag(ptr, &tag);
5164 switch (tag >> 3) {
5165 // optional uint32 ctl_num = 1;
5166 case 1:
5167 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5168 _Internal::set_has_ctl_num(&has_bits);
5169 _impl_.ctl_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5170 CHK_(ptr);
5171 } else {
5172 goto handle_unusual;
5173 }
5174 continue;
5175 default:
5176 goto handle_unusual;
5177 } // switch
5178 handle_unusual:
5179 if ((tag == 0) || ((tag & 7) == 4)) {
5180 CHK_(ptr);
5181 ctx->SetLastTag(tag);
5182 goto message_done;
5183 }
5184 ptr = UnknownFieldParse(
5185 tag,
5186 _internal_metadata_.mutable_unknown_fields<std::string>(),
5187 ptr, ctx);
5188 CHK_(ptr != nullptr);
5189 } // while
5190 message_done:
5191 _impl_._has_bits_.Or(has_bits);
5192 return ptr;
5193 failure:
5194 ptr = nullptr;
5195 goto message_done;
5196 #undef CHK_
5197 }
5198
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5199 ::uint8_t* MdpCmdReleaseBwFtraceEvent::_InternalSerialize(
5200 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5201 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5202 ::uint32_t cached_has_bits = 0;
5203 (void) cached_has_bits;
5204
5205 cached_has_bits = _impl_._has_bits_[0];
5206 // optional uint32 ctl_num = 1;
5207 if (cached_has_bits & 0x00000001u) {
5208 target = stream->EnsureSpace(target);
5209 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ctl_num(), target);
5210 }
5211
5212 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5213 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5214 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5215 }
5216 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5217 return target;
5218 }
5219
ByteSizeLong() const5220 size_t MdpCmdReleaseBwFtraceEvent::ByteSizeLong() const {
5221 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5222 size_t total_size = 0;
5223
5224 ::uint32_t cached_has_bits = 0;
5225 // Prevent compiler warnings about cached_has_bits being unused
5226 (void) cached_has_bits;
5227
5228 // optional uint32 ctl_num = 1;
5229 cached_has_bits = _impl_._has_bits_[0];
5230 if (cached_has_bits & 0x00000001u) {
5231 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ctl_num());
5232 }
5233
5234 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5235 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5236 }
5237 int cached_size = ::_pbi::ToCachedSize(total_size);
5238 SetCachedSize(cached_size);
5239 return total_size;
5240 }
5241
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5242 void MdpCmdReleaseBwFtraceEvent::CheckTypeAndMergeFrom(
5243 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5244 MergeFrom(*::_pbi::DownCast<const MdpCmdReleaseBwFtraceEvent*>(
5245 &from));
5246 }
5247
MergeFrom(const MdpCmdReleaseBwFtraceEvent & from)5248 void MdpCmdReleaseBwFtraceEvent::MergeFrom(const MdpCmdReleaseBwFtraceEvent& from) {
5249 MdpCmdReleaseBwFtraceEvent* const _this = this;
5250 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5251 GOOGLE_DCHECK_NE(&from, _this);
5252 ::uint32_t cached_has_bits = 0;
5253 (void) cached_has_bits;
5254
5255 if (from._internal_has_ctl_num()) {
5256 _this->_internal_set_ctl_num(from._internal_ctl_num());
5257 }
5258 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5259 }
5260
CopyFrom(const MdpCmdReleaseBwFtraceEvent & from)5261 void MdpCmdReleaseBwFtraceEvent::CopyFrom(const MdpCmdReleaseBwFtraceEvent& from) {
5262 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCmdReleaseBwFtraceEvent)
5263 if (&from == this) return;
5264 Clear();
5265 MergeFrom(from);
5266 }
5267
IsInitialized() const5268 bool MdpCmdReleaseBwFtraceEvent::IsInitialized() const {
5269 return true;
5270 }
5271
InternalSwap(MdpCmdReleaseBwFtraceEvent * other)5272 void MdpCmdReleaseBwFtraceEvent::InternalSwap(MdpCmdReleaseBwFtraceEvent* other) {
5273 using std::swap;
5274 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5275 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5276 swap(_impl_.ctl_num_, other->_impl_.ctl_num_);
5277 }
5278
GetTypeName() const5279 std::string MdpCmdReleaseBwFtraceEvent::GetTypeName() const {
5280 return "perfetto.protos.MdpCmdReleaseBwFtraceEvent";
5281 }
5282
5283
5284 // ===================================================================
5285
5286 class MdpMixerUpdateFtraceEvent::_Internal {
5287 public:
5288 using HasBits = decltype(std::declval<MdpMixerUpdateFtraceEvent>()._impl_._has_bits_);
set_has_mixer_num(HasBits * has_bits)5289 static void set_has_mixer_num(HasBits* has_bits) {
5290 (*has_bits)[0] |= 1u;
5291 }
5292 };
5293
MdpMixerUpdateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5294 MdpMixerUpdateFtraceEvent::MdpMixerUpdateFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5295 bool is_message_owned)
5296 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5297 SharedCtor(arena, is_message_owned);
5298 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpMixerUpdateFtraceEvent)
5299 }
MdpMixerUpdateFtraceEvent(const MdpMixerUpdateFtraceEvent & from)5300 MdpMixerUpdateFtraceEvent::MdpMixerUpdateFtraceEvent(const MdpMixerUpdateFtraceEvent& from)
5301 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5302 MdpMixerUpdateFtraceEvent* const _this = this; (void)_this;
5303 new (&_impl_) Impl_{
5304 decltype(_impl_._has_bits_){from._impl_._has_bits_}
5305 , /*decltype(_impl_._cached_size_)*/{}
5306 , decltype(_impl_.mixer_num_){}};
5307
5308 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5309 _this->_impl_.mixer_num_ = from._impl_.mixer_num_;
5310 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpMixerUpdateFtraceEvent)
5311 }
5312
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5313 inline void MdpMixerUpdateFtraceEvent::SharedCtor(
5314 ::_pb::Arena* arena, bool is_message_owned) {
5315 (void)arena;
5316 (void)is_message_owned;
5317 new (&_impl_) Impl_{
5318 decltype(_impl_._has_bits_){}
5319 , /*decltype(_impl_._cached_size_)*/{}
5320 , decltype(_impl_.mixer_num_){0u}
5321 };
5322 }
5323
~MdpMixerUpdateFtraceEvent()5324 MdpMixerUpdateFtraceEvent::~MdpMixerUpdateFtraceEvent() {
5325 // @@protoc_insertion_point(destructor:perfetto.protos.MdpMixerUpdateFtraceEvent)
5326 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5327 (void)arena;
5328 return;
5329 }
5330 SharedDtor();
5331 }
5332
SharedDtor()5333 inline void MdpMixerUpdateFtraceEvent::SharedDtor() {
5334 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5335 }
5336
SetCachedSize(int size) const5337 void MdpMixerUpdateFtraceEvent::SetCachedSize(int size) const {
5338 _impl_._cached_size_.Set(size);
5339 }
5340
Clear()5341 void MdpMixerUpdateFtraceEvent::Clear() {
5342 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpMixerUpdateFtraceEvent)
5343 ::uint32_t cached_has_bits = 0;
5344 // Prevent compiler warnings about cached_has_bits being unused
5345 (void) cached_has_bits;
5346
5347 _impl_.mixer_num_ = 0u;
5348 _impl_._has_bits_.Clear();
5349 _internal_metadata_.Clear<std::string>();
5350 }
5351
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5352 const char* MdpMixerUpdateFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5353 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5354 _Internal::HasBits has_bits{};
5355 while (!ctx->Done(&ptr)) {
5356 ::uint32_t tag;
5357 ptr = ::_pbi::ReadTag(ptr, &tag);
5358 switch (tag >> 3) {
5359 // optional uint32 mixer_num = 1;
5360 case 1:
5361 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5362 _Internal::set_has_mixer_num(&has_bits);
5363 _impl_.mixer_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5364 CHK_(ptr);
5365 } else {
5366 goto handle_unusual;
5367 }
5368 continue;
5369 default:
5370 goto handle_unusual;
5371 } // switch
5372 handle_unusual:
5373 if ((tag == 0) || ((tag & 7) == 4)) {
5374 CHK_(ptr);
5375 ctx->SetLastTag(tag);
5376 goto message_done;
5377 }
5378 ptr = UnknownFieldParse(
5379 tag,
5380 _internal_metadata_.mutable_unknown_fields<std::string>(),
5381 ptr, ctx);
5382 CHK_(ptr != nullptr);
5383 } // while
5384 message_done:
5385 _impl_._has_bits_.Or(has_bits);
5386 return ptr;
5387 failure:
5388 ptr = nullptr;
5389 goto message_done;
5390 #undef CHK_
5391 }
5392
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5393 ::uint8_t* MdpMixerUpdateFtraceEvent::_InternalSerialize(
5394 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5395 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpMixerUpdateFtraceEvent)
5396 ::uint32_t cached_has_bits = 0;
5397 (void) cached_has_bits;
5398
5399 cached_has_bits = _impl_._has_bits_[0];
5400 // optional uint32 mixer_num = 1;
5401 if (cached_has_bits & 0x00000001u) {
5402 target = stream->EnsureSpace(target);
5403 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_mixer_num(), target);
5404 }
5405
5406 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5407 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5408 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5409 }
5410 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpMixerUpdateFtraceEvent)
5411 return target;
5412 }
5413
ByteSizeLong() const5414 size_t MdpMixerUpdateFtraceEvent::ByteSizeLong() const {
5415 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpMixerUpdateFtraceEvent)
5416 size_t total_size = 0;
5417
5418 ::uint32_t cached_has_bits = 0;
5419 // Prevent compiler warnings about cached_has_bits being unused
5420 (void) cached_has_bits;
5421
5422 // optional uint32 mixer_num = 1;
5423 cached_has_bits = _impl_._has_bits_[0];
5424 if (cached_has_bits & 0x00000001u) {
5425 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mixer_num());
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 MdpMixerUpdateFtraceEvent::CheckTypeAndMergeFrom(
5437 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5438 MergeFrom(*::_pbi::DownCast<const MdpMixerUpdateFtraceEvent*>(
5439 &from));
5440 }
5441
MergeFrom(const MdpMixerUpdateFtraceEvent & from)5442 void MdpMixerUpdateFtraceEvent::MergeFrom(const MdpMixerUpdateFtraceEvent& from) {
5443 MdpMixerUpdateFtraceEvent* const _this = this;
5444 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpMixerUpdateFtraceEvent)
5445 GOOGLE_DCHECK_NE(&from, _this);
5446 ::uint32_t cached_has_bits = 0;
5447 (void) cached_has_bits;
5448
5449 if (from._internal_has_mixer_num()) {
5450 _this->_internal_set_mixer_num(from._internal_mixer_num());
5451 }
5452 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5453 }
5454
CopyFrom(const MdpMixerUpdateFtraceEvent & from)5455 void MdpMixerUpdateFtraceEvent::CopyFrom(const MdpMixerUpdateFtraceEvent& from) {
5456 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpMixerUpdateFtraceEvent)
5457 if (&from == this) return;
5458 Clear();
5459 MergeFrom(from);
5460 }
5461
IsInitialized() const5462 bool MdpMixerUpdateFtraceEvent::IsInitialized() const {
5463 return true;
5464 }
5465
InternalSwap(MdpMixerUpdateFtraceEvent * other)5466 void MdpMixerUpdateFtraceEvent::InternalSwap(MdpMixerUpdateFtraceEvent* other) {
5467 using std::swap;
5468 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5469 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5470 swap(_impl_.mixer_num_, other->_impl_.mixer_num_);
5471 }
5472
GetTypeName() const5473 std::string MdpMixerUpdateFtraceEvent::GetTypeName() const {
5474 return "perfetto.protos.MdpMixerUpdateFtraceEvent";
5475 }
5476
5477
5478 // ===================================================================
5479
5480 class MdpPerfSetWmLevelsFtraceEvent::_Internal {
5481 public:
5482 using HasBits = decltype(std::declval<MdpPerfSetWmLevelsFtraceEvent>()._impl_._has_bits_);
set_has_pnum(HasBits * has_bits)5483 static void set_has_pnum(HasBits* has_bits) {
5484 (*has_bits)[0] |= 1u;
5485 }
set_has_use_space(HasBits * has_bits)5486 static void set_has_use_space(HasBits* has_bits) {
5487 (*has_bits)[0] |= 2u;
5488 }
set_has_priority_bytes(HasBits * has_bits)5489 static void set_has_priority_bytes(HasBits* has_bits) {
5490 (*has_bits)[0] |= 4u;
5491 }
set_has_wm0(HasBits * has_bits)5492 static void set_has_wm0(HasBits* has_bits) {
5493 (*has_bits)[0] |= 8u;
5494 }
set_has_wm1(HasBits * has_bits)5495 static void set_has_wm1(HasBits* has_bits) {
5496 (*has_bits)[0] |= 16u;
5497 }
set_has_wm2(HasBits * has_bits)5498 static void set_has_wm2(HasBits* has_bits) {
5499 (*has_bits)[0] |= 32u;
5500 }
set_has_mb_cnt(HasBits * has_bits)5501 static void set_has_mb_cnt(HasBits* has_bits) {
5502 (*has_bits)[0] |= 64u;
5503 }
set_has_mb_size(HasBits * has_bits)5504 static void set_has_mb_size(HasBits* has_bits) {
5505 (*has_bits)[0] |= 128u;
5506 }
5507 };
5508
MdpPerfSetWmLevelsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5509 MdpPerfSetWmLevelsFtraceEvent::MdpPerfSetWmLevelsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5510 bool is_message_owned)
5511 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5512 SharedCtor(arena, is_message_owned);
5513 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5514 }
MdpPerfSetWmLevelsFtraceEvent(const MdpPerfSetWmLevelsFtraceEvent & from)5515 MdpPerfSetWmLevelsFtraceEvent::MdpPerfSetWmLevelsFtraceEvent(const MdpPerfSetWmLevelsFtraceEvent& from)
5516 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5517 MdpPerfSetWmLevelsFtraceEvent* const _this = this; (void)_this;
5518 new (&_impl_) Impl_{
5519 decltype(_impl_._has_bits_){from._impl_._has_bits_}
5520 , /*decltype(_impl_._cached_size_)*/{}
5521 , decltype(_impl_.pnum_){}
5522 , decltype(_impl_.use_space_){}
5523 , decltype(_impl_.priority_bytes_){}
5524 , decltype(_impl_.wm0_){}
5525 , decltype(_impl_.wm1_){}
5526 , decltype(_impl_.wm2_){}
5527 , decltype(_impl_.mb_cnt_){}
5528 , decltype(_impl_.mb_size_){}};
5529
5530 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5531 ::memcpy(&_impl_.pnum_, &from._impl_.pnum_,
5532 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.mb_size_) -
5533 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.mb_size_));
5534 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5535 }
5536
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5537 inline void MdpPerfSetWmLevelsFtraceEvent::SharedCtor(
5538 ::_pb::Arena* arena, bool is_message_owned) {
5539 (void)arena;
5540 (void)is_message_owned;
5541 new (&_impl_) Impl_{
5542 decltype(_impl_._has_bits_){}
5543 , /*decltype(_impl_._cached_size_)*/{}
5544 , decltype(_impl_.pnum_){0u}
5545 , decltype(_impl_.use_space_){0u}
5546 , decltype(_impl_.priority_bytes_){0u}
5547 , decltype(_impl_.wm0_){0u}
5548 , decltype(_impl_.wm1_){0u}
5549 , decltype(_impl_.wm2_){0u}
5550 , decltype(_impl_.mb_cnt_){0u}
5551 , decltype(_impl_.mb_size_){0u}
5552 };
5553 }
5554
~MdpPerfSetWmLevelsFtraceEvent()5555 MdpPerfSetWmLevelsFtraceEvent::~MdpPerfSetWmLevelsFtraceEvent() {
5556 // @@protoc_insertion_point(destructor:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5557 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5558 (void)arena;
5559 return;
5560 }
5561 SharedDtor();
5562 }
5563
SharedDtor()5564 inline void MdpPerfSetWmLevelsFtraceEvent::SharedDtor() {
5565 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5566 }
5567
SetCachedSize(int size) const5568 void MdpPerfSetWmLevelsFtraceEvent::SetCachedSize(int size) const {
5569 _impl_._cached_size_.Set(size);
5570 }
5571
Clear()5572 void MdpPerfSetWmLevelsFtraceEvent::Clear() {
5573 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5574 ::uint32_t cached_has_bits = 0;
5575 // Prevent compiler warnings about cached_has_bits being unused
5576 (void) cached_has_bits;
5577
5578 cached_has_bits = _impl_._has_bits_[0];
5579 if (cached_has_bits & 0x000000ffu) {
5580 ::memset(&_impl_.pnum_, 0, static_cast<size_t>(
5581 reinterpret_cast<char*>(&_impl_.mb_size_) -
5582 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.mb_size_));
5583 }
5584 _impl_._has_bits_.Clear();
5585 _internal_metadata_.Clear<std::string>();
5586 }
5587
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5588 const char* MdpPerfSetWmLevelsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5589 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5590 _Internal::HasBits has_bits{};
5591 while (!ctx->Done(&ptr)) {
5592 ::uint32_t tag;
5593 ptr = ::_pbi::ReadTag(ptr, &tag);
5594 switch (tag >> 3) {
5595 // optional uint32 pnum = 1;
5596 case 1:
5597 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5598 _Internal::set_has_pnum(&has_bits);
5599 _impl_.pnum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5600 CHK_(ptr);
5601 } else {
5602 goto handle_unusual;
5603 }
5604 continue;
5605 // optional uint32 use_space = 2;
5606 case 2:
5607 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5608 _Internal::set_has_use_space(&has_bits);
5609 _impl_.use_space_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5610 CHK_(ptr);
5611 } else {
5612 goto handle_unusual;
5613 }
5614 continue;
5615 // optional uint32 priority_bytes = 3;
5616 case 3:
5617 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
5618 _Internal::set_has_priority_bytes(&has_bits);
5619 _impl_.priority_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5620 CHK_(ptr);
5621 } else {
5622 goto handle_unusual;
5623 }
5624 continue;
5625 // optional uint32 wm0 = 4;
5626 case 4:
5627 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
5628 _Internal::set_has_wm0(&has_bits);
5629 _impl_.wm0_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5630 CHK_(ptr);
5631 } else {
5632 goto handle_unusual;
5633 }
5634 continue;
5635 // optional uint32 wm1 = 5;
5636 case 5:
5637 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
5638 _Internal::set_has_wm1(&has_bits);
5639 _impl_.wm1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5640 CHK_(ptr);
5641 } else {
5642 goto handle_unusual;
5643 }
5644 continue;
5645 // optional uint32 wm2 = 6;
5646 case 6:
5647 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
5648 _Internal::set_has_wm2(&has_bits);
5649 _impl_.wm2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5650 CHK_(ptr);
5651 } else {
5652 goto handle_unusual;
5653 }
5654 continue;
5655 // optional uint32 mb_cnt = 7;
5656 case 7:
5657 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
5658 _Internal::set_has_mb_cnt(&has_bits);
5659 _impl_.mb_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5660 CHK_(ptr);
5661 } else {
5662 goto handle_unusual;
5663 }
5664 continue;
5665 // optional uint32 mb_size = 8;
5666 case 8:
5667 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
5668 _Internal::set_has_mb_size(&has_bits);
5669 _impl_.mb_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5670 CHK_(ptr);
5671 } else {
5672 goto handle_unusual;
5673 }
5674 continue;
5675 default:
5676 goto handle_unusual;
5677 } // switch
5678 handle_unusual:
5679 if ((tag == 0) || ((tag & 7) == 4)) {
5680 CHK_(ptr);
5681 ctx->SetLastTag(tag);
5682 goto message_done;
5683 }
5684 ptr = UnknownFieldParse(
5685 tag,
5686 _internal_metadata_.mutable_unknown_fields<std::string>(),
5687 ptr, ctx);
5688 CHK_(ptr != nullptr);
5689 } // while
5690 message_done:
5691 _impl_._has_bits_.Or(has_bits);
5692 return ptr;
5693 failure:
5694 ptr = nullptr;
5695 goto message_done;
5696 #undef CHK_
5697 }
5698
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const5699 ::uint8_t* MdpPerfSetWmLevelsFtraceEvent::_InternalSerialize(
5700 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
5701 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5702 ::uint32_t cached_has_bits = 0;
5703 (void) cached_has_bits;
5704
5705 cached_has_bits = _impl_._has_bits_[0];
5706 // optional uint32 pnum = 1;
5707 if (cached_has_bits & 0x00000001u) {
5708 target = stream->EnsureSpace(target);
5709 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pnum(), target);
5710 }
5711
5712 // optional uint32 use_space = 2;
5713 if (cached_has_bits & 0x00000002u) {
5714 target = stream->EnsureSpace(target);
5715 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_use_space(), target);
5716 }
5717
5718 // optional uint32 priority_bytes = 3;
5719 if (cached_has_bits & 0x00000004u) {
5720 target = stream->EnsureSpace(target);
5721 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_priority_bytes(), target);
5722 }
5723
5724 // optional uint32 wm0 = 4;
5725 if (cached_has_bits & 0x00000008u) {
5726 target = stream->EnsureSpace(target);
5727 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_wm0(), target);
5728 }
5729
5730 // optional uint32 wm1 = 5;
5731 if (cached_has_bits & 0x00000010u) {
5732 target = stream->EnsureSpace(target);
5733 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_wm1(), target);
5734 }
5735
5736 // optional uint32 wm2 = 6;
5737 if (cached_has_bits & 0x00000020u) {
5738 target = stream->EnsureSpace(target);
5739 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_wm2(), target);
5740 }
5741
5742 // optional uint32 mb_cnt = 7;
5743 if (cached_has_bits & 0x00000040u) {
5744 target = stream->EnsureSpace(target);
5745 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_mb_cnt(), target);
5746 }
5747
5748 // optional uint32 mb_size = 8;
5749 if (cached_has_bits & 0x00000080u) {
5750 target = stream->EnsureSpace(target);
5751 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_mb_size(), target);
5752 }
5753
5754 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5755 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
5756 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
5757 }
5758 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5759 return target;
5760 }
5761
ByteSizeLong() const5762 size_t MdpPerfSetWmLevelsFtraceEvent::ByteSizeLong() const {
5763 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5764 size_t total_size = 0;
5765
5766 ::uint32_t cached_has_bits = 0;
5767 // Prevent compiler warnings about cached_has_bits being unused
5768 (void) cached_has_bits;
5769
5770 cached_has_bits = _impl_._has_bits_[0];
5771 if (cached_has_bits & 0x000000ffu) {
5772 // optional uint32 pnum = 1;
5773 if (cached_has_bits & 0x00000001u) {
5774 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pnum());
5775 }
5776
5777 // optional uint32 use_space = 2;
5778 if (cached_has_bits & 0x00000002u) {
5779 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_use_space());
5780 }
5781
5782 // optional uint32 priority_bytes = 3;
5783 if (cached_has_bits & 0x00000004u) {
5784 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_priority_bytes());
5785 }
5786
5787 // optional uint32 wm0 = 4;
5788 if (cached_has_bits & 0x00000008u) {
5789 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_wm0());
5790 }
5791
5792 // optional uint32 wm1 = 5;
5793 if (cached_has_bits & 0x00000010u) {
5794 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_wm1());
5795 }
5796
5797 // optional uint32 wm2 = 6;
5798 if (cached_has_bits & 0x00000020u) {
5799 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_wm2());
5800 }
5801
5802 // optional uint32 mb_cnt = 7;
5803 if (cached_has_bits & 0x00000040u) {
5804 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mb_cnt());
5805 }
5806
5807 // optional uint32 mb_size = 8;
5808 if (cached_has_bits & 0x00000080u) {
5809 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mb_size());
5810 }
5811
5812 }
5813 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
5814 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
5815 }
5816 int cached_size = ::_pbi::ToCachedSize(total_size);
5817 SetCachedSize(cached_size);
5818 return total_size;
5819 }
5820
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)5821 void MdpPerfSetWmLevelsFtraceEvent::CheckTypeAndMergeFrom(
5822 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
5823 MergeFrom(*::_pbi::DownCast<const MdpPerfSetWmLevelsFtraceEvent*>(
5824 &from));
5825 }
5826
MergeFrom(const MdpPerfSetWmLevelsFtraceEvent & from)5827 void MdpPerfSetWmLevelsFtraceEvent::MergeFrom(const MdpPerfSetWmLevelsFtraceEvent& from) {
5828 MdpPerfSetWmLevelsFtraceEvent* const _this = this;
5829 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5830 GOOGLE_DCHECK_NE(&from, _this);
5831 ::uint32_t cached_has_bits = 0;
5832 (void) cached_has_bits;
5833
5834 cached_has_bits = from._impl_._has_bits_[0];
5835 if (cached_has_bits & 0x000000ffu) {
5836 if (cached_has_bits & 0x00000001u) {
5837 _this->_impl_.pnum_ = from._impl_.pnum_;
5838 }
5839 if (cached_has_bits & 0x00000002u) {
5840 _this->_impl_.use_space_ = from._impl_.use_space_;
5841 }
5842 if (cached_has_bits & 0x00000004u) {
5843 _this->_impl_.priority_bytes_ = from._impl_.priority_bytes_;
5844 }
5845 if (cached_has_bits & 0x00000008u) {
5846 _this->_impl_.wm0_ = from._impl_.wm0_;
5847 }
5848 if (cached_has_bits & 0x00000010u) {
5849 _this->_impl_.wm1_ = from._impl_.wm1_;
5850 }
5851 if (cached_has_bits & 0x00000020u) {
5852 _this->_impl_.wm2_ = from._impl_.wm2_;
5853 }
5854 if (cached_has_bits & 0x00000040u) {
5855 _this->_impl_.mb_cnt_ = from._impl_.mb_cnt_;
5856 }
5857 if (cached_has_bits & 0x00000080u) {
5858 _this->_impl_.mb_size_ = from._impl_.mb_size_;
5859 }
5860 _this->_impl_._has_bits_[0] |= cached_has_bits;
5861 }
5862 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5863 }
5864
CopyFrom(const MdpPerfSetWmLevelsFtraceEvent & from)5865 void MdpPerfSetWmLevelsFtraceEvent::CopyFrom(const MdpPerfSetWmLevelsFtraceEvent& from) {
5866 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpPerfSetWmLevelsFtraceEvent)
5867 if (&from == this) return;
5868 Clear();
5869 MergeFrom(from);
5870 }
5871
IsInitialized() const5872 bool MdpPerfSetWmLevelsFtraceEvent::IsInitialized() const {
5873 return true;
5874 }
5875
InternalSwap(MdpPerfSetWmLevelsFtraceEvent * other)5876 void MdpPerfSetWmLevelsFtraceEvent::InternalSwap(MdpPerfSetWmLevelsFtraceEvent* other) {
5877 using std::swap;
5878 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
5879 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
5880 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
5881 PROTOBUF_FIELD_OFFSET(MdpPerfSetWmLevelsFtraceEvent, _impl_.mb_size_)
5882 + sizeof(MdpPerfSetWmLevelsFtraceEvent::_impl_.mb_size_) // NOLINT
5883 - PROTOBUF_FIELD_OFFSET(MdpPerfSetWmLevelsFtraceEvent, _impl_.pnum_)>(
5884 reinterpret_cast<char*>(&_impl_.pnum_),
5885 reinterpret_cast<char*>(&other->_impl_.pnum_));
5886 }
5887
GetTypeName() const5888 std::string MdpPerfSetWmLevelsFtraceEvent::GetTypeName() const {
5889 return "perfetto.protos.MdpPerfSetWmLevelsFtraceEvent";
5890 }
5891
5892
5893 // ===================================================================
5894
5895 class MdpVideoUnderrunDoneFtraceEvent::_Internal {
5896 public:
5897 using HasBits = decltype(std::declval<MdpVideoUnderrunDoneFtraceEvent>()._impl_._has_bits_);
set_has_ctl_num(HasBits * has_bits)5898 static void set_has_ctl_num(HasBits* has_bits) {
5899 (*has_bits)[0] |= 1u;
5900 }
set_has_underrun_cnt(HasBits * has_bits)5901 static void set_has_underrun_cnt(HasBits* has_bits) {
5902 (*has_bits)[0] |= 2u;
5903 }
5904 };
5905
MdpVideoUnderrunDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)5906 MdpVideoUnderrunDoneFtraceEvent::MdpVideoUnderrunDoneFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
5907 bool is_message_owned)
5908 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
5909 SharedCtor(arena, is_message_owned);
5910 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
5911 }
MdpVideoUnderrunDoneFtraceEvent(const MdpVideoUnderrunDoneFtraceEvent & from)5912 MdpVideoUnderrunDoneFtraceEvent::MdpVideoUnderrunDoneFtraceEvent(const MdpVideoUnderrunDoneFtraceEvent& from)
5913 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
5914 MdpVideoUnderrunDoneFtraceEvent* const _this = this; (void)_this;
5915 new (&_impl_) Impl_{
5916 decltype(_impl_._has_bits_){from._impl_._has_bits_}
5917 , /*decltype(_impl_._cached_size_)*/{}
5918 , decltype(_impl_.ctl_num_){}
5919 , decltype(_impl_.underrun_cnt_){}};
5920
5921 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
5922 ::memcpy(&_impl_.ctl_num_, &from._impl_.ctl_num_,
5923 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.underrun_cnt_) -
5924 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.underrun_cnt_));
5925 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
5926 }
5927
SharedCtor(::_pb::Arena * arena,bool is_message_owned)5928 inline void MdpVideoUnderrunDoneFtraceEvent::SharedCtor(
5929 ::_pb::Arena* arena, bool is_message_owned) {
5930 (void)arena;
5931 (void)is_message_owned;
5932 new (&_impl_) Impl_{
5933 decltype(_impl_._has_bits_){}
5934 , /*decltype(_impl_._cached_size_)*/{}
5935 , decltype(_impl_.ctl_num_){0u}
5936 , decltype(_impl_.underrun_cnt_){0u}
5937 };
5938 }
5939
~MdpVideoUnderrunDoneFtraceEvent()5940 MdpVideoUnderrunDoneFtraceEvent::~MdpVideoUnderrunDoneFtraceEvent() {
5941 // @@protoc_insertion_point(destructor:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
5942 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
5943 (void)arena;
5944 return;
5945 }
5946 SharedDtor();
5947 }
5948
SharedDtor()5949 inline void MdpVideoUnderrunDoneFtraceEvent::SharedDtor() {
5950 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
5951 }
5952
SetCachedSize(int size) const5953 void MdpVideoUnderrunDoneFtraceEvent::SetCachedSize(int size) const {
5954 _impl_._cached_size_.Set(size);
5955 }
5956
Clear()5957 void MdpVideoUnderrunDoneFtraceEvent::Clear() {
5958 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
5959 ::uint32_t cached_has_bits = 0;
5960 // Prevent compiler warnings about cached_has_bits being unused
5961 (void) cached_has_bits;
5962
5963 cached_has_bits = _impl_._has_bits_[0];
5964 if (cached_has_bits & 0x00000003u) {
5965 ::memset(&_impl_.ctl_num_, 0, static_cast<size_t>(
5966 reinterpret_cast<char*>(&_impl_.underrun_cnt_) -
5967 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.underrun_cnt_));
5968 }
5969 _impl_._has_bits_.Clear();
5970 _internal_metadata_.Clear<std::string>();
5971 }
5972
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)5973 const char* MdpVideoUnderrunDoneFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
5974 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
5975 _Internal::HasBits has_bits{};
5976 while (!ctx->Done(&ptr)) {
5977 ::uint32_t tag;
5978 ptr = ::_pbi::ReadTag(ptr, &tag);
5979 switch (tag >> 3) {
5980 // optional uint32 ctl_num = 1;
5981 case 1:
5982 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
5983 _Internal::set_has_ctl_num(&has_bits);
5984 _impl_.ctl_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5985 CHK_(ptr);
5986 } else {
5987 goto handle_unusual;
5988 }
5989 continue;
5990 // optional uint32 underrun_cnt = 2;
5991 case 2:
5992 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
5993 _Internal::set_has_underrun_cnt(&has_bits);
5994 _impl_.underrun_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
5995 CHK_(ptr);
5996 } else {
5997 goto handle_unusual;
5998 }
5999 continue;
6000 default:
6001 goto handle_unusual;
6002 } // switch
6003 handle_unusual:
6004 if ((tag == 0) || ((tag & 7) == 4)) {
6005 CHK_(ptr);
6006 ctx->SetLastTag(tag);
6007 goto message_done;
6008 }
6009 ptr = UnknownFieldParse(
6010 tag,
6011 _internal_metadata_.mutable_unknown_fields<std::string>(),
6012 ptr, ctx);
6013 CHK_(ptr != nullptr);
6014 } // while
6015 message_done:
6016 _impl_._has_bits_.Or(has_bits);
6017 return ptr;
6018 failure:
6019 ptr = nullptr;
6020 goto message_done;
6021 #undef CHK_
6022 }
6023
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6024 ::uint8_t* MdpVideoUnderrunDoneFtraceEvent::_InternalSerialize(
6025 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6026 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
6027 ::uint32_t cached_has_bits = 0;
6028 (void) cached_has_bits;
6029
6030 cached_has_bits = _impl_._has_bits_[0];
6031 // optional uint32 ctl_num = 1;
6032 if (cached_has_bits & 0x00000001u) {
6033 target = stream->EnsureSpace(target);
6034 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ctl_num(), target);
6035 }
6036
6037 // optional uint32 underrun_cnt = 2;
6038 if (cached_has_bits & 0x00000002u) {
6039 target = stream->EnsureSpace(target);
6040 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_underrun_cnt(), target);
6041 }
6042
6043 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6044 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6045 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6046 }
6047 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
6048 return target;
6049 }
6050
ByteSizeLong() const6051 size_t MdpVideoUnderrunDoneFtraceEvent::ByteSizeLong() const {
6052 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
6053 size_t total_size = 0;
6054
6055 ::uint32_t cached_has_bits = 0;
6056 // Prevent compiler warnings about cached_has_bits being unused
6057 (void) cached_has_bits;
6058
6059 cached_has_bits = _impl_._has_bits_[0];
6060 if (cached_has_bits & 0x00000003u) {
6061 // optional uint32 ctl_num = 1;
6062 if (cached_has_bits & 0x00000001u) {
6063 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ctl_num());
6064 }
6065
6066 // optional uint32 underrun_cnt = 2;
6067 if (cached_has_bits & 0x00000002u) {
6068 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_underrun_cnt());
6069 }
6070
6071 }
6072 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6073 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6074 }
6075 int cached_size = ::_pbi::ToCachedSize(total_size);
6076 SetCachedSize(cached_size);
6077 return total_size;
6078 }
6079
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6080 void MdpVideoUnderrunDoneFtraceEvent::CheckTypeAndMergeFrom(
6081 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6082 MergeFrom(*::_pbi::DownCast<const MdpVideoUnderrunDoneFtraceEvent*>(
6083 &from));
6084 }
6085
MergeFrom(const MdpVideoUnderrunDoneFtraceEvent & from)6086 void MdpVideoUnderrunDoneFtraceEvent::MergeFrom(const MdpVideoUnderrunDoneFtraceEvent& from) {
6087 MdpVideoUnderrunDoneFtraceEvent* const _this = this;
6088 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
6089 GOOGLE_DCHECK_NE(&from, _this);
6090 ::uint32_t cached_has_bits = 0;
6091 (void) cached_has_bits;
6092
6093 cached_has_bits = from._impl_._has_bits_[0];
6094 if (cached_has_bits & 0x00000003u) {
6095 if (cached_has_bits & 0x00000001u) {
6096 _this->_impl_.ctl_num_ = from._impl_.ctl_num_;
6097 }
6098 if (cached_has_bits & 0x00000002u) {
6099 _this->_impl_.underrun_cnt_ = from._impl_.underrun_cnt_;
6100 }
6101 _this->_impl_._has_bits_[0] |= cached_has_bits;
6102 }
6103 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6104 }
6105
CopyFrom(const MdpVideoUnderrunDoneFtraceEvent & from)6106 void MdpVideoUnderrunDoneFtraceEvent::CopyFrom(const MdpVideoUnderrunDoneFtraceEvent& from) {
6107 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpVideoUnderrunDoneFtraceEvent)
6108 if (&from == this) return;
6109 Clear();
6110 MergeFrom(from);
6111 }
6112
IsInitialized() const6113 bool MdpVideoUnderrunDoneFtraceEvent::IsInitialized() const {
6114 return true;
6115 }
6116
InternalSwap(MdpVideoUnderrunDoneFtraceEvent * other)6117 void MdpVideoUnderrunDoneFtraceEvent::InternalSwap(MdpVideoUnderrunDoneFtraceEvent* other) {
6118 using std::swap;
6119 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6120 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6121 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
6122 PROTOBUF_FIELD_OFFSET(MdpVideoUnderrunDoneFtraceEvent, _impl_.underrun_cnt_)
6123 + sizeof(MdpVideoUnderrunDoneFtraceEvent::_impl_.underrun_cnt_) // NOLINT
6124 - PROTOBUF_FIELD_OFFSET(MdpVideoUnderrunDoneFtraceEvent, _impl_.ctl_num_)>(
6125 reinterpret_cast<char*>(&_impl_.ctl_num_),
6126 reinterpret_cast<char*>(&other->_impl_.ctl_num_));
6127 }
6128
GetTypeName() const6129 std::string MdpVideoUnderrunDoneFtraceEvent::GetTypeName() const {
6130 return "perfetto.protos.MdpVideoUnderrunDoneFtraceEvent";
6131 }
6132
6133
6134 // ===================================================================
6135
6136 class MdpCmdWaitPingpongFtraceEvent::_Internal {
6137 public:
6138 using HasBits = decltype(std::declval<MdpCmdWaitPingpongFtraceEvent>()._impl_._has_bits_);
set_has_ctl_num(HasBits * has_bits)6139 static void set_has_ctl_num(HasBits* has_bits) {
6140 (*has_bits)[0] |= 1u;
6141 }
set_has_kickoff_cnt(HasBits * has_bits)6142 static void set_has_kickoff_cnt(HasBits* has_bits) {
6143 (*has_bits)[0] |= 2u;
6144 }
6145 };
6146
MdpCmdWaitPingpongFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6147 MdpCmdWaitPingpongFtraceEvent::MdpCmdWaitPingpongFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6148 bool is_message_owned)
6149 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6150 SharedCtor(arena, is_message_owned);
6151 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6152 }
MdpCmdWaitPingpongFtraceEvent(const MdpCmdWaitPingpongFtraceEvent & from)6153 MdpCmdWaitPingpongFtraceEvent::MdpCmdWaitPingpongFtraceEvent(const MdpCmdWaitPingpongFtraceEvent& from)
6154 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6155 MdpCmdWaitPingpongFtraceEvent* const _this = this; (void)_this;
6156 new (&_impl_) Impl_{
6157 decltype(_impl_._has_bits_){from._impl_._has_bits_}
6158 , /*decltype(_impl_._cached_size_)*/{}
6159 , decltype(_impl_.ctl_num_){}
6160 , decltype(_impl_.kickoff_cnt_){}};
6161
6162 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6163 ::memcpy(&_impl_.ctl_num_, &from._impl_.ctl_num_,
6164 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.kickoff_cnt_) -
6165 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.kickoff_cnt_));
6166 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6167 }
6168
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6169 inline void MdpCmdWaitPingpongFtraceEvent::SharedCtor(
6170 ::_pb::Arena* arena, bool is_message_owned) {
6171 (void)arena;
6172 (void)is_message_owned;
6173 new (&_impl_) Impl_{
6174 decltype(_impl_._has_bits_){}
6175 , /*decltype(_impl_._cached_size_)*/{}
6176 , decltype(_impl_.ctl_num_){0u}
6177 , decltype(_impl_.kickoff_cnt_){0}
6178 };
6179 }
6180
~MdpCmdWaitPingpongFtraceEvent()6181 MdpCmdWaitPingpongFtraceEvent::~MdpCmdWaitPingpongFtraceEvent() {
6182 // @@protoc_insertion_point(destructor:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6183 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6184 (void)arena;
6185 return;
6186 }
6187 SharedDtor();
6188 }
6189
SharedDtor()6190 inline void MdpCmdWaitPingpongFtraceEvent::SharedDtor() {
6191 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6192 }
6193
SetCachedSize(int size) const6194 void MdpCmdWaitPingpongFtraceEvent::SetCachedSize(int size) const {
6195 _impl_._cached_size_.Set(size);
6196 }
6197
Clear()6198 void MdpCmdWaitPingpongFtraceEvent::Clear() {
6199 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6200 ::uint32_t cached_has_bits = 0;
6201 // Prevent compiler warnings about cached_has_bits being unused
6202 (void) cached_has_bits;
6203
6204 cached_has_bits = _impl_._has_bits_[0];
6205 if (cached_has_bits & 0x00000003u) {
6206 ::memset(&_impl_.ctl_num_, 0, static_cast<size_t>(
6207 reinterpret_cast<char*>(&_impl_.kickoff_cnt_) -
6208 reinterpret_cast<char*>(&_impl_.ctl_num_)) + sizeof(_impl_.kickoff_cnt_));
6209 }
6210 _impl_._has_bits_.Clear();
6211 _internal_metadata_.Clear<std::string>();
6212 }
6213
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6214 const char* MdpCmdWaitPingpongFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6215 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6216 _Internal::HasBits has_bits{};
6217 while (!ctx->Done(&ptr)) {
6218 ::uint32_t tag;
6219 ptr = ::_pbi::ReadTag(ptr, &tag);
6220 switch (tag >> 3) {
6221 // optional uint32 ctl_num = 1;
6222 case 1:
6223 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
6224 _Internal::set_has_ctl_num(&has_bits);
6225 _impl_.ctl_num_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6226 CHK_(ptr);
6227 } else {
6228 goto handle_unusual;
6229 }
6230 continue;
6231 // optional int32 kickoff_cnt = 2;
6232 case 2:
6233 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6234 _Internal::set_has_kickoff_cnt(&has_bits);
6235 _impl_.kickoff_cnt_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6236 CHK_(ptr);
6237 } else {
6238 goto handle_unusual;
6239 }
6240 continue;
6241 default:
6242 goto handle_unusual;
6243 } // switch
6244 handle_unusual:
6245 if ((tag == 0) || ((tag & 7) == 4)) {
6246 CHK_(ptr);
6247 ctx->SetLastTag(tag);
6248 goto message_done;
6249 }
6250 ptr = UnknownFieldParse(
6251 tag,
6252 _internal_metadata_.mutable_unknown_fields<std::string>(),
6253 ptr, ctx);
6254 CHK_(ptr != nullptr);
6255 } // while
6256 message_done:
6257 _impl_._has_bits_.Or(has_bits);
6258 return ptr;
6259 failure:
6260 ptr = nullptr;
6261 goto message_done;
6262 #undef CHK_
6263 }
6264
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6265 ::uint8_t* MdpCmdWaitPingpongFtraceEvent::_InternalSerialize(
6266 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6267 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6268 ::uint32_t cached_has_bits = 0;
6269 (void) cached_has_bits;
6270
6271 cached_has_bits = _impl_._has_bits_[0];
6272 // optional uint32 ctl_num = 1;
6273 if (cached_has_bits & 0x00000001u) {
6274 target = stream->EnsureSpace(target);
6275 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_ctl_num(), target);
6276 }
6277
6278 // optional int32 kickoff_cnt = 2;
6279 if (cached_has_bits & 0x00000002u) {
6280 target = stream->EnsureSpace(target);
6281 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_kickoff_cnt(), target);
6282 }
6283
6284 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6285 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6286 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6287 }
6288 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6289 return target;
6290 }
6291
ByteSizeLong() const6292 size_t MdpCmdWaitPingpongFtraceEvent::ByteSizeLong() const {
6293 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6294 size_t total_size = 0;
6295
6296 ::uint32_t cached_has_bits = 0;
6297 // Prevent compiler warnings about cached_has_bits being unused
6298 (void) cached_has_bits;
6299
6300 cached_has_bits = _impl_._has_bits_[0];
6301 if (cached_has_bits & 0x00000003u) {
6302 // optional uint32 ctl_num = 1;
6303 if (cached_has_bits & 0x00000001u) {
6304 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ctl_num());
6305 }
6306
6307 // optional int32 kickoff_cnt = 2;
6308 if (cached_has_bits & 0x00000002u) {
6309 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_kickoff_cnt());
6310 }
6311
6312 }
6313 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6314 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6315 }
6316 int cached_size = ::_pbi::ToCachedSize(total_size);
6317 SetCachedSize(cached_size);
6318 return total_size;
6319 }
6320
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6321 void MdpCmdWaitPingpongFtraceEvent::CheckTypeAndMergeFrom(
6322 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6323 MergeFrom(*::_pbi::DownCast<const MdpCmdWaitPingpongFtraceEvent*>(
6324 &from));
6325 }
6326
MergeFrom(const MdpCmdWaitPingpongFtraceEvent & from)6327 void MdpCmdWaitPingpongFtraceEvent::MergeFrom(const MdpCmdWaitPingpongFtraceEvent& from) {
6328 MdpCmdWaitPingpongFtraceEvent* const _this = this;
6329 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6330 GOOGLE_DCHECK_NE(&from, _this);
6331 ::uint32_t cached_has_bits = 0;
6332 (void) cached_has_bits;
6333
6334 cached_has_bits = from._impl_._has_bits_[0];
6335 if (cached_has_bits & 0x00000003u) {
6336 if (cached_has_bits & 0x00000001u) {
6337 _this->_impl_.ctl_num_ = from._impl_.ctl_num_;
6338 }
6339 if (cached_has_bits & 0x00000002u) {
6340 _this->_impl_.kickoff_cnt_ = from._impl_.kickoff_cnt_;
6341 }
6342 _this->_impl_._has_bits_[0] |= cached_has_bits;
6343 }
6344 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6345 }
6346
CopyFrom(const MdpCmdWaitPingpongFtraceEvent & from)6347 void MdpCmdWaitPingpongFtraceEvent::CopyFrom(const MdpCmdWaitPingpongFtraceEvent& from) {
6348 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpCmdWaitPingpongFtraceEvent)
6349 if (&from == this) return;
6350 Clear();
6351 MergeFrom(from);
6352 }
6353
IsInitialized() const6354 bool MdpCmdWaitPingpongFtraceEvent::IsInitialized() const {
6355 return true;
6356 }
6357
InternalSwap(MdpCmdWaitPingpongFtraceEvent * other)6358 void MdpCmdWaitPingpongFtraceEvent::InternalSwap(MdpCmdWaitPingpongFtraceEvent* other) {
6359 using std::swap;
6360 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6361 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6362 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
6363 PROTOBUF_FIELD_OFFSET(MdpCmdWaitPingpongFtraceEvent, _impl_.kickoff_cnt_)
6364 + sizeof(MdpCmdWaitPingpongFtraceEvent::_impl_.kickoff_cnt_) // NOLINT
6365 - PROTOBUF_FIELD_OFFSET(MdpCmdWaitPingpongFtraceEvent, _impl_.ctl_num_)>(
6366 reinterpret_cast<char*>(&_impl_.ctl_num_),
6367 reinterpret_cast<char*>(&other->_impl_.ctl_num_));
6368 }
6369
GetTypeName() const6370 std::string MdpCmdWaitPingpongFtraceEvent::GetTypeName() const {
6371 return "perfetto.protos.MdpCmdWaitPingpongFtraceEvent";
6372 }
6373
6374
6375 // ===================================================================
6376
6377 class MdpPerfPrefillCalcFtraceEvent::_Internal {
6378 public:
6379 using HasBits = decltype(std::declval<MdpPerfPrefillCalcFtraceEvent>()._impl_._has_bits_);
set_has_pnum(HasBits * has_bits)6380 static void set_has_pnum(HasBits* has_bits) {
6381 (*has_bits)[0] |= 1u;
6382 }
set_has_latency_buf(HasBits * has_bits)6383 static void set_has_latency_buf(HasBits* has_bits) {
6384 (*has_bits)[0] |= 2u;
6385 }
set_has_ot(HasBits * has_bits)6386 static void set_has_ot(HasBits* has_bits) {
6387 (*has_bits)[0] |= 4u;
6388 }
set_has_y_buf(HasBits * has_bits)6389 static void set_has_y_buf(HasBits* has_bits) {
6390 (*has_bits)[0] |= 8u;
6391 }
set_has_y_scaler(HasBits * has_bits)6392 static void set_has_y_scaler(HasBits* has_bits) {
6393 (*has_bits)[0] |= 16u;
6394 }
set_has_pp_lines(HasBits * has_bits)6395 static void set_has_pp_lines(HasBits* has_bits) {
6396 (*has_bits)[0] |= 32u;
6397 }
set_has_pp_bytes(HasBits * has_bits)6398 static void set_has_pp_bytes(HasBits* has_bits) {
6399 (*has_bits)[0] |= 64u;
6400 }
set_has_post_sc(HasBits * has_bits)6401 static void set_has_post_sc(HasBits* has_bits) {
6402 (*has_bits)[0] |= 128u;
6403 }
set_has_fbc_bytes(HasBits * has_bits)6404 static void set_has_fbc_bytes(HasBits* has_bits) {
6405 (*has_bits)[0] |= 256u;
6406 }
set_has_prefill_bytes(HasBits * has_bits)6407 static void set_has_prefill_bytes(HasBits* has_bits) {
6408 (*has_bits)[0] |= 512u;
6409 }
6410 };
6411
MdpPerfPrefillCalcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6412 MdpPerfPrefillCalcFtraceEvent::MdpPerfPrefillCalcFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6413 bool is_message_owned)
6414 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6415 SharedCtor(arena, is_message_owned);
6416 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6417 }
MdpPerfPrefillCalcFtraceEvent(const MdpPerfPrefillCalcFtraceEvent & from)6418 MdpPerfPrefillCalcFtraceEvent::MdpPerfPrefillCalcFtraceEvent(const MdpPerfPrefillCalcFtraceEvent& from)
6419 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6420 MdpPerfPrefillCalcFtraceEvent* const _this = this; (void)_this;
6421 new (&_impl_) Impl_{
6422 decltype(_impl_._has_bits_){from._impl_._has_bits_}
6423 , /*decltype(_impl_._cached_size_)*/{}
6424 , decltype(_impl_.pnum_){}
6425 , decltype(_impl_.latency_buf_){}
6426 , decltype(_impl_.ot_){}
6427 , decltype(_impl_.y_buf_){}
6428 , decltype(_impl_.y_scaler_){}
6429 , decltype(_impl_.pp_lines_){}
6430 , decltype(_impl_.pp_bytes_){}
6431 , decltype(_impl_.post_sc_){}
6432 , decltype(_impl_.fbc_bytes_){}
6433 , decltype(_impl_.prefill_bytes_){}};
6434
6435 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6436 ::memcpy(&_impl_.pnum_, &from._impl_.pnum_,
6437 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prefill_bytes_) -
6438 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.prefill_bytes_));
6439 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6440 }
6441
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6442 inline void MdpPerfPrefillCalcFtraceEvent::SharedCtor(
6443 ::_pb::Arena* arena, bool is_message_owned) {
6444 (void)arena;
6445 (void)is_message_owned;
6446 new (&_impl_) Impl_{
6447 decltype(_impl_._has_bits_){}
6448 , /*decltype(_impl_._cached_size_)*/{}
6449 , decltype(_impl_.pnum_){0u}
6450 , decltype(_impl_.latency_buf_){0u}
6451 , decltype(_impl_.ot_){0u}
6452 , decltype(_impl_.y_buf_){0u}
6453 , decltype(_impl_.y_scaler_){0u}
6454 , decltype(_impl_.pp_lines_){0u}
6455 , decltype(_impl_.pp_bytes_){0u}
6456 , decltype(_impl_.post_sc_){0u}
6457 , decltype(_impl_.fbc_bytes_){0u}
6458 , decltype(_impl_.prefill_bytes_){0u}
6459 };
6460 }
6461
~MdpPerfPrefillCalcFtraceEvent()6462 MdpPerfPrefillCalcFtraceEvent::~MdpPerfPrefillCalcFtraceEvent() {
6463 // @@protoc_insertion_point(destructor:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6464 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6465 (void)arena;
6466 return;
6467 }
6468 SharedDtor();
6469 }
6470
SharedDtor()6471 inline void MdpPerfPrefillCalcFtraceEvent::SharedDtor() {
6472 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6473 }
6474
SetCachedSize(int size) const6475 void MdpPerfPrefillCalcFtraceEvent::SetCachedSize(int size) const {
6476 _impl_._cached_size_.Set(size);
6477 }
6478
Clear()6479 void MdpPerfPrefillCalcFtraceEvent::Clear() {
6480 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6481 ::uint32_t cached_has_bits = 0;
6482 // Prevent compiler warnings about cached_has_bits being unused
6483 (void) cached_has_bits;
6484
6485 cached_has_bits = _impl_._has_bits_[0];
6486 if (cached_has_bits & 0x000000ffu) {
6487 ::memset(&_impl_.pnum_, 0, static_cast<size_t>(
6488 reinterpret_cast<char*>(&_impl_.post_sc_) -
6489 reinterpret_cast<char*>(&_impl_.pnum_)) + sizeof(_impl_.post_sc_));
6490 }
6491 if (cached_has_bits & 0x00000300u) {
6492 ::memset(&_impl_.fbc_bytes_, 0, static_cast<size_t>(
6493 reinterpret_cast<char*>(&_impl_.prefill_bytes_) -
6494 reinterpret_cast<char*>(&_impl_.fbc_bytes_)) + sizeof(_impl_.prefill_bytes_));
6495 }
6496 _impl_._has_bits_.Clear();
6497 _internal_metadata_.Clear<std::string>();
6498 }
6499
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6500 const char* MdpPerfPrefillCalcFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6501 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6502 _Internal::HasBits has_bits{};
6503 while (!ctx->Done(&ptr)) {
6504 ::uint32_t tag;
6505 ptr = ::_pbi::ReadTag(ptr, &tag);
6506 switch (tag >> 3) {
6507 // optional uint32 pnum = 1;
6508 case 1:
6509 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
6510 _Internal::set_has_pnum(&has_bits);
6511 _impl_.pnum_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6512 CHK_(ptr);
6513 } else {
6514 goto handle_unusual;
6515 }
6516 continue;
6517 // optional uint32 latency_buf = 2;
6518 case 2:
6519 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6520 _Internal::set_has_latency_buf(&has_bits);
6521 _impl_.latency_buf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6522 CHK_(ptr);
6523 } else {
6524 goto handle_unusual;
6525 }
6526 continue;
6527 // optional uint32 ot = 3;
6528 case 3:
6529 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
6530 _Internal::set_has_ot(&has_bits);
6531 _impl_.ot_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6532 CHK_(ptr);
6533 } else {
6534 goto handle_unusual;
6535 }
6536 continue;
6537 // optional uint32 y_buf = 4;
6538 case 4:
6539 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
6540 _Internal::set_has_y_buf(&has_bits);
6541 _impl_.y_buf_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6542 CHK_(ptr);
6543 } else {
6544 goto handle_unusual;
6545 }
6546 continue;
6547 // optional uint32 y_scaler = 5;
6548 case 5:
6549 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
6550 _Internal::set_has_y_scaler(&has_bits);
6551 _impl_.y_scaler_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6552 CHK_(ptr);
6553 } else {
6554 goto handle_unusual;
6555 }
6556 continue;
6557 // optional uint32 pp_lines = 6;
6558 case 6:
6559 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
6560 _Internal::set_has_pp_lines(&has_bits);
6561 _impl_.pp_lines_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6562 CHK_(ptr);
6563 } else {
6564 goto handle_unusual;
6565 }
6566 continue;
6567 // optional uint32 pp_bytes = 7;
6568 case 7:
6569 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
6570 _Internal::set_has_pp_bytes(&has_bits);
6571 _impl_.pp_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6572 CHK_(ptr);
6573 } else {
6574 goto handle_unusual;
6575 }
6576 continue;
6577 // optional uint32 post_sc = 8;
6578 case 8:
6579 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
6580 _Internal::set_has_post_sc(&has_bits);
6581 _impl_.post_sc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6582 CHK_(ptr);
6583 } else {
6584 goto handle_unusual;
6585 }
6586 continue;
6587 // optional uint32 fbc_bytes = 9;
6588 case 9:
6589 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
6590 _Internal::set_has_fbc_bytes(&has_bits);
6591 _impl_.fbc_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6592 CHK_(ptr);
6593 } else {
6594 goto handle_unusual;
6595 }
6596 continue;
6597 // optional uint32 prefill_bytes = 10;
6598 case 10:
6599 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
6600 _Internal::set_has_prefill_bytes(&has_bits);
6601 _impl_.prefill_bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6602 CHK_(ptr);
6603 } else {
6604 goto handle_unusual;
6605 }
6606 continue;
6607 default:
6608 goto handle_unusual;
6609 } // switch
6610 handle_unusual:
6611 if ((tag == 0) || ((tag & 7) == 4)) {
6612 CHK_(ptr);
6613 ctx->SetLastTag(tag);
6614 goto message_done;
6615 }
6616 ptr = UnknownFieldParse(
6617 tag,
6618 _internal_metadata_.mutable_unknown_fields<std::string>(),
6619 ptr, ctx);
6620 CHK_(ptr != nullptr);
6621 } // while
6622 message_done:
6623 _impl_._has_bits_.Or(has_bits);
6624 return ptr;
6625 failure:
6626 ptr = nullptr;
6627 goto message_done;
6628 #undef CHK_
6629 }
6630
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const6631 ::uint8_t* MdpPerfPrefillCalcFtraceEvent::_InternalSerialize(
6632 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
6633 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6634 ::uint32_t cached_has_bits = 0;
6635 (void) cached_has_bits;
6636
6637 cached_has_bits = _impl_._has_bits_[0];
6638 // optional uint32 pnum = 1;
6639 if (cached_has_bits & 0x00000001u) {
6640 target = stream->EnsureSpace(target);
6641 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_pnum(), target);
6642 }
6643
6644 // optional uint32 latency_buf = 2;
6645 if (cached_has_bits & 0x00000002u) {
6646 target = stream->EnsureSpace(target);
6647 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_latency_buf(), target);
6648 }
6649
6650 // optional uint32 ot = 3;
6651 if (cached_has_bits & 0x00000004u) {
6652 target = stream->EnsureSpace(target);
6653 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_ot(), target);
6654 }
6655
6656 // optional uint32 y_buf = 4;
6657 if (cached_has_bits & 0x00000008u) {
6658 target = stream->EnsureSpace(target);
6659 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_y_buf(), target);
6660 }
6661
6662 // optional uint32 y_scaler = 5;
6663 if (cached_has_bits & 0x00000010u) {
6664 target = stream->EnsureSpace(target);
6665 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_y_scaler(), target);
6666 }
6667
6668 // optional uint32 pp_lines = 6;
6669 if (cached_has_bits & 0x00000020u) {
6670 target = stream->EnsureSpace(target);
6671 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_pp_lines(), target);
6672 }
6673
6674 // optional uint32 pp_bytes = 7;
6675 if (cached_has_bits & 0x00000040u) {
6676 target = stream->EnsureSpace(target);
6677 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_pp_bytes(), target);
6678 }
6679
6680 // optional uint32 post_sc = 8;
6681 if (cached_has_bits & 0x00000080u) {
6682 target = stream->EnsureSpace(target);
6683 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_post_sc(), target);
6684 }
6685
6686 // optional uint32 fbc_bytes = 9;
6687 if (cached_has_bits & 0x00000100u) {
6688 target = stream->EnsureSpace(target);
6689 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_fbc_bytes(), target);
6690 }
6691
6692 // optional uint32 prefill_bytes = 10;
6693 if (cached_has_bits & 0x00000200u) {
6694 target = stream->EnsureSpace(target);
6695 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_prefill_bytes(), target);
6696 }
6697
6698 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6699 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
6700 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
6701 }
6702 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6703 return target;
6704 }
6705
ByteSizeLong() const6706 size_t MdpPerfPrefillCalcFtraceEvent::ByteSizeLong() const {
6707 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6708 size_t total_size = 0;
6709
6710 ::uint32_t cached_has_bits = 0;
6711 // Prevent compiler warnings about cached_has_bits being unused
6712 (void) cached_has_bits;
6713
6714 cached_has_bits = _impl_._has_bits_[0];
6715 if (cached_has_bits & 0x000000ffu) {
6716 // optional uint32 pnum = 1;
6717 if (cached_has_bits & 0x00000001u) {
6718 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pnum());
6719 }
6720
6721 // optional uint32 latency_buf = 2;
6722 if (cached_has_bits & 0x00000002u) {
6723 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_latency_buf());
6724 }
6725
6726 // optional uint32 ot = 3;
6727 if (cached_has_bits & 0x00000004u) {
6728 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ot());
6729 }
6730
6731 // optional uint32 y_buf = 4;
6732 if (cached_has_bits & 0x00000008u) {
6733 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_y_buf());
6734 }
6735
6736 // optional uint32 y_scaler = 5;
6737 if (cached_has_bits & 0x00000010u) {
6738 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_y_scaler());
6739 }
6740
6741 // optional uint32 pp_lines = 6;
6742 if (cached_has_bits & 0x00000020u) {
6743 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pp_lines());
6744 }
6745
6746 // optional uint32 pp_bytes = 7;
6747 if (cached_has_bits & 0x00000040u) {
6748 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_pp_bytes());
6749 }
6750
6751 // optional uint32 post_sc = 8;
6752 if (cached_has_bits & 0x00000080u) {
6753 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_post_sc());
6754 }
6755
6756 }
6757 if (cached_has_bits & 0x00000300u) {
6758 // optional uint32 fbc_bytes = 9;
6759 if (cached_has_bits & 0x00000100u) {
6760 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_fbc_bytes());
6761 }
6762
6763 // optional uint32 prefill_bytes = 10;
6764 if (cached_has_bits & 0x00000200u) {
6765 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_prefill_bytes());
6766 }
6767
6768 }
6769 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
6770 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
6771 }
6772 int cached_size = ::_pbi::ToCachedSize(total_size);
6773 SetCachedSize(cached_size);
6774 return total_size;
6775 }
6776
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)6777 void MdpPerfPrefillCalcFtraceEvent::CheckTypeAndMergeFrom(
6778 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
6779 MergeFrom(*::_pbi::DownCast<const MdpPerfPrefillCalcFtraceEvent*>(
6780 &from));
6781 }
6782
MergeFrom(const MdpPerfPrefillCalcFtraceEvent & from)6783 void MdpPerfPrefillCalcFtraceEvent::MergeFrom(const MdpPerfPrefillCalcFtraceEvent& from) {
6784 MdpPerfPrefillCalcFtraceEvent* const _this = this;
6785 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6786 GOOGLE_DCHECK_NE(&from, _this);
6787 ::uint32_t cached_has_bits = 0;
6788 (void) cached_has_bits;
6789
6790 cached_has_bits = from._impl_._has_bits_[0];
6791 if (cached_has_bits & 0x000000ffu) {
6792 if (cached_has_bits & 0x00000001u) {
6793 _this->_impl_.pnum_ = from._impl_.pnum_;
6794 }
6795 if (cached_has_bits & 0x00000002u) {
6796 _this->_impl_.latency_buf_ = from._impl_.latency_buf_;
6797 }
6798 if (cached_has_bits & 0x00000004u) {
6799 _this->_impl_.ot_ = from._impl_.ot_;
6800 }
6801 if (cached_has_bits & 0x00000008u) {
6802 _this->_impl_.y_buf_ = from._impl_.y_buf_;
6803 }
6804 if (cached_has_bits & 0x00000010u) {
6805 _this->_impl_.y_scaler_ = from._impl_.y_scaler_;
6806 }
6807 if (cached_has_bits & 0x00000020u) {
6808 _this->_impl_.pp_lines_ = from._impl_.pp_lines_;
6809 }
6810 if (cached_has_bits & 0x00000040u) {
6811 _this->_impl_.pp_bytes_ = from._impl_.pp_bytes_;
6812 }
6813 if (cached_has_bits & 0x00000080u) {
6814 _this->_impl_.post_sc_ = from._impl_.post_sc_;
6815 }
6816 _this->_impl_._has_bits_[0] |= cached_has_bits;
6817 }
6818 if (cached_has_bits & 0x00000300u) {
6819 if (cached_has_bits & 0x00000100u) {
6820 _this->_impl_.fbc_bytes_ = from._impl_.fbc_bytes_;
6821 }
6822 if (cached_has_bits & 0x00000200u) {
6823 _this->_impl_.prefill_bytes_ = from._impl_.prefill_bytes_;
6824 }
6825 _this->_impl_._has_bits_[0] |= cached_has_bits;
6826 }
6827 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6828 }
6829
CopyFrom(const MdpPerfPrefillCalcFtraceEvent & from)6830 void MdpPerfPrefillCalcFtraceEvent::CopyFrom(const MdpPerfPrefillCalcFtraceEvent& from) {
6831 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpPerfPrefillCalcFtraceEvent)
6832 if (&from == this) return;
6833 Clear();
6834 MergeFrom(from);
6835 }
6836
IsInitialized() const6837 bool MdpPerfPrefillCalcFtraceEvent::IsInitialized() const {
6838 return true;
6839 }
6840
InternalSwap(MdpPerfPrefillCalcFtraceEvent * other)6841 void MdpPerfPrefillCalcFtraceEvent::InternalSwap(MdpPerfPrefillCalcFtraceEvent* other) {
6842 using std::swap;
6843 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
6844 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
6845 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
6846 PROTOBUF_FIELD_OFFSET(MdpPerfPrefillCalcFtraceEvent, _impl_.prefill_bytes_)
6847 + sizeof(MdpPerfPrefillCalcFtraceEvent::_impl_.prefill_bytes_) // NOLINT
6848 - PROTOBUF_FIELD_OFFSET(MdpPerfPrefillCalcFtraceEvent, _impl_.pnum_)>(
6849 reinterpret_cast<char*>(&_impl_.pnum_),
6850 reinterpret_cast<char*>(&other->_impl_.pnum_));
6851 }
6852
GetTypeName() const6853 std::string MdpPerfPrefillCalcFtraceEvent::GetTypeName() const {
6854 return "perfetto.protos.MdpPerfPrefillCalcFtraceEvent";
6855 }
6856
6857
6858 // ===================================================================
6859
6860 class MdpPerfUpdateBusFtraceEvent::_Internal {
6861 public:
6862 using HasBits = decltype(std::declval<MdpPerfUpdateBusFtraceEvent>()._impl_._has_bits_);
set_has_client(HasBits * has_bits)6863 static void set_has_client(HasBits* has_bits) {
6864 (*has_bits)[0] |= 4u;
6865 }
set_has_ab_quota(HasBits * has_bits)6866 static void set_has_ab_quota(HasBits* has_bits) {
6867 (*has_bits)[0] |= 1u;
6868 }
set_has_ib_quota(HasBits * has_bits)6869 static void set_has_ib_quota(HasBits* has_bits) {
6870 (*has_bits)[0] |= 2u;
6871 }
6872 };
6873
MdpPerfUpdateBusFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)6874 MdpPerfUpdateBusFtraceEvent::MdpPerfUpdateBusFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
6875 bool is_message_owned)
6876 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
6877 SharedCtor(arena, is_message_owned);
6878 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
6879 }
MdpPerfUpdateBusFtraceEvent(const MdpPerfUpdateBusFtraceEvent & from)6880 MdpPerfUpdateBusFtraceEvent::MdpPerfUpdateBusFtraceEvent(const MdpPerfUpdateBusFtraceEvent& from)
6881 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
6882 MdpPerfUpdateBusFtraceEvent* const _this = this; (void)_this;
6883 new (&_impl_) Impl_{
6884 decltype(_impl_._has_bits_){from._impl_._has_bits_}
6885 , /*decltype(_impl_._cached_size_)*/{}
6886 , decltype(_impl_.ab_quota_){}
6887 , decltype(_impl_.ib_quota_){}
6888 , decltype(_impl_.client_){}};
6889
6890 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
6891 ::memcpy(&_impl_.ab_quota_, &from._impl_.ab_quota_,
6892 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.client_) -
6893 reinterpret_cast<char*>(&_impl_.ab_quota_)) + sizeof(_impl_.client_));
6894 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
6895 }
6896
SharedCtor(::_pb::Arena * arena,bool is_message_owned)6897 inline void MdpPerfUpdateBusFtraceEvent::SharedCtor(
6898 ::_pb::Arena* arena, bool is_message_owned) {
6899 (void)arena;
6900 (void)is_message_owned;
6901 new (&_impl_) Impl_{
6902 decltype(_impl_._has_bits_){}
6903 , /*decltype(_impl_._cached_size_)*/{}
6904 , decltype(_impl_.ab_quota_){::uint64_t{0u}}
6905 , decltype(_impl_.ib_quota_){::uint64_t{0u}}
6906 , decltype(_impl_.client_){0}
6907 };
6908 }
6909
~MdpPerfUpdateBusFtraceEvent()6910 MdpPerfUpdateBusFtraceEvent::~MdpPerfUpdateBusFtraceEvent() {
6911 // @@protoc_insertion_point(destructor:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
6912 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
6913 (void)arena;
6914 return;
6915 }
6916 SharedDtor();
6917 }
6918
SharedDtor()6919 inline void MdpPerfUpdateBusFtraceEvent::SharedDtor() {
6920 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
6921 }
6922
SetCachedSize(int size) const6923 void MdpPerfUpdateBusFtraceEvent::SetCachedSize(int size) const {
6924 _impl_._cached_size_.Set(size);
6925 }
6926
Clear()6927 void MdpPerfUpdateBusFtraceEvent::Clear() {
6928 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
6929 ::uint32_t cached_has_bits = 0;
6930 // Prevent compiler warnings about cached_has_bits being unused
6931 (void) cached_has_bits;
6932
6933 cached_has_bits = _impl_._has_bits_[0];
6934 if (cached_has_bits & 0x00000007u) {
6935 ::memset(&_impl_.ab_quota_, 0, static_cast<size_t>(
6936 reinterpret_cast<char*>(&_impl_.client_) -
6937 reinterpret_cast<char*>(&_impl_.ab_quota_)) + sizeof(_impl_.client_));
6938 }
6939 _impl_._has_bits_.Clear();
6940 _internal_metadata_.Clear<std::string>();
6941 }
6942
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)6943 const char* MdpPerfUpdateBusFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
6944 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
6945 _Internal::HasBits has_bits{};
6946 while (!ctx->Done(&ptr)) {
6947 ::uint32_t tag;
6948 ptr = ::_pbi::ReadTag(ptr, &tag);
6949 switch (tag >> 3) {
6950 // optional int32 client = 1;
6951 case 1:
6952 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
6953 _Internal::set_has_client(&has_bits);
6954 _impl_.client_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
6955 CHK_(ptr);
6956 } else {
6957 goto handle_unusual;
6958 }
6959 continue;
6960 // optional uint64 ab_quota = 2;
6961 case 2:
6962 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
6963 _Internal::set_has_ab_quota(&has_bits);
6964 _impl_.ab_quota_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6965 CHK_(ptr);
6966 } else {
6967 goto handle_unusual;
6968 }
6969 continue;
6970 // optional uint64 ib_quota = 3;
6971 case 3:
6972 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
6973 _Internal::set_has_ib_quota(&has_bits);
6974 _impl_.ib_quota_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
6975 CHK_(ptr);
6976 } else {
6977 goto handle_unusual;
6978 }
6979 continue;
6980 default:
6981 goto handle_unusual;
6982 } // switch
6983 handle_unusual:
6984 if ((tag == 0) || ((tag & 7) == 4)) {
6985 CHK_(ptr);
6986 ctx->SetLastTag(tag);
6987 goto message_done;
6988 }
6989 ptr = UnknownFieldParse(
6990 tag,
6991 _internal_metadata_.mutable_unknown_fields<std::string>(),
6992 ptr, ctx);
6993 CHK_(ptr != nullptr);
6994 } // while
6995 message_done:
6996 _impl_._has_bits_.Or(has_bits);
6997 return ptr;
6998 failure:
6999 ptr = nullptr;
7000 goto message_done;
7001 #undef CHK_
7002 }
7003
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7004 ::uint8_t* MdpPerfUpdateBusFtraceEvent::_InternalSerialize(
7005 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7006 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
7007 ::uint32_t cached_has_bits = 0;
7008 (void) cached_has_bits;
7009
7010 cached_has_bits = _impl_._has_bits_[0];
7011 // optional int32 client = 1;
7012 if (cached_has_bits & 0x00000004u) {
7013 target = stream->EnsureSpace(target);
7014 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_client(), target);
7015 }
7016
7017 // optional uint64 ab_quota = 2;
7018 if (cached_has_bits & 0x00000001u) {
7019 target = stream->EnsureSpace(target);
7020 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ab_quota(), target);
7021 }
7022
7023 // optional uint64 ib_quota = 3;
7024 if (cached_has_bits & 0x00000002u) {
7025 target = stream->EnsureSpace(target);
7026 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_ib_quota(), target);
7027 }
7028
7029 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7030 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7031 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7032 }
7033 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
7034 return target;
7035 }
7036
ByteSizeLong() const7037 size_t MdpPerfUpdateBusFtraceEvent::ByteSizeLong() const {
7038 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
7039 size_t total_size = 0;
7040
7041 ::uint32_t cached_has_bits = 0;
7042 // Prevent compiler warnings about cached_has_bits being unused
7043 (void) cached_has_bits;
7044
7045 cached_has_bits = _impl_._has_bits_[0];
7046 if (cached_has_bits & 0x00000007u) {
7047 // optional uint64 ab_quota = 2;
7048 if (cached_has_bits & 0x00000001u) {
7049 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ab_quota());
7050 }
7051
7052 // optional uint64 ib_quota = 3;
7053 if (cached_has_bits & 0x00000002u) {
7054 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ib_quota());
7055 }
7056
7057 // optional int32 client = 1;
7058 if (cached_has_bits & 0x00000004u) {
7059 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_client());
7060 }
7061
7062 }
7063 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7064 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7065 }
7066 int cached_size = ::_pbi::ToCachedSize(total_size);
7067 SetCachedSize(cached_size);
7068 return total_size;
7069 }
7070
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7071 void MdpPerfUpdateBusFtraceEvent::CheckTypeAndMergeFrom(
7072 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7073 MergeFrom(*::_pbi::DownCast<const MdpPerfUpdateBusFtraceEvent*>(
7074 &from));
7075 }
7076
MergeFrom(const MdpPerfUpdateBusFtraceEvent & from)7077 void MdpPerfUpdateBusFtraceEvent::MergeFrom(const MdpPerfUpdateBusFtraceEvent& from) {
7078 MdpPerfUpdateBusFtraceEvent* const _this = this;
7079 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
7080 GOOGLE_DCHECK_NE(&from, _this);
7081 ::uint32_t cached_has_bits = 0;
7082 (void) cached_has_bits;
7083
7084 cached_has_bits = from._impl_._has_bits_[0];
7085 if (cached_has_bits & 0x00000007u) {
7086 if (cached_has_bits & 0x00000001u) {
7087 _this->_impl_.ab_quota_ = from._impl_.ab_quota_;
7088 }
7089 if (cached_has_bits & 0x00000002u) {
7090 _this->_impl_.ib_quota_ = from._impl_.ib_quota_;
7091 }
7092 if (cached_has_bits & 0x00000004u) {
7093 _this->_impl_.client_ = from._impl_.client_;
7094 }
7095 _this->_impl_._has_bits_[0] |= cached_has_bits;
7096 }
7097 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7098 }
7099
CopyFrom(const MdpPerfUpdateBusFtraceEvent & from)7100 void MdpPerfUpdateBusFtraceEvent::CopyFrom(const MdpPerfUpdateBusFtraceEvent& from) {
7101 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MdpPerfUpdateBusFtraceEvent)
7102 if (&from == this) return;
7103 Clear();
7104 MergeFrom(from);
7105 }
7106
IsInitialized() const7107 bool MdpPerfUpdateBusFtraceEvent::IsInitialized() const {
7108 return true;
7109 }
7110
InternalSwap(MdpPerfUpdateBusFtraceEvent * other)7111 void MdpPerfUpdateBusFtraceEvent::InternalSwap(MdpPerfUpdateBusFtraceEvent* other) {
7112 using std::swap;
7113 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7114 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
7115 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
7116 PROTOBUF_FIELD_OFFSET(MdpPerfUpdateBusFtraceEvent, _impl_.client_)
7117 + sizeof(MdpPerfUpdateBusFtraceEvent::_impl_.client_) // NOLINT
7118 - PROTOBUF_FIELD_OFFSET(MdpPerfUpdateBusFtraceEvent, _impl_.ab_quota_)>(
7119 reinterpret_cast<char*>(&_impl_.ab_quota_),
7120 reinterpret_cast<char*>(&other->_impl_.ab_quota_));
7121 }
7122
GetTypeName() const7123 std::string MdpPerfUpdateBusFtraceEvent::GetTypeName() const {
7124 return "perfetto.protos.MdpPerfUpdateBusFtraceEvent";
7125 }
7126
7127
7128 // ===================================================================
7129
7130 class RotatorBwAoAsContextFtraceEvent::_Internal {
7131 public:
7132 using HasBits = decltype(std::declval<RotatorBwAoAsContextFtraceEvent>()._impl_._has_bits_);
set_has_state(HasBits * has_bits)7133 static void set_has_state(HasBits* has_bits) {
7134 (*has_bits)[0] |= 1u;
7135 }
7136 };
7137
RotatorBwAoAsContextFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)7138 RotatorBwAoAsContextFtraceEvent::RotatorBwAoAsContextFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
7139 bool is_message_owned)
7140 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
7141 SharedCtor(arena, is_message_owned);
7142 // @@protoc_insertion_point(arena_constructor:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7143 }
RotatorBwAoAsContextFtraceEvent(const RotatorBwAoAsContextFtraceEvent & from)7144 RotatorBwAoAsContextFtraceEvent::RotatorBwAoAsContextFtraceEvent(const RotatorBwAoAsContextFtraceEvent& from)
7145 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
7146 RotatorBwAoAsContextFtraceEvent* const _this = this; (void)_this;
7147 new (&_impl_) Impl_{
7148 decltype(_impl_._has_bits_){from._impl_._has_bits_}
7149 , /*decltype(_impl_._cached_size_)*/{}
7150 , decltype(_impl_.state_){}};
7151
7152 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7153 _this->_impl_.state_ = from._impl_.state_;
7154 // @@protoc_insertion_point(copy_constructor:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7155 }
7156
SharedCtor(::_pb::Arena * arena,bool is_message_owned)7157 inline void RotatorBwAoAsContextFtraceEvent::SharedCtor(
7158 ::_pb::Arena* arena, bool is_message_owned) {
7159 (void)arena;
7160 (void)is_message_owned;
7161 new (&_impl_) Impl_{
7162 decltype(_impl_._has_bits_){}
7163 , /*decltype(_impl_._cached_size_)*/{}
7164 , decltype(_impl_.state_){0u}
7165 };
7166 }
7167
~RotatorBwAoAsContextFtraceEvent()7168 RotatorBwAoAsContextFtraceEvent::~RotatorBwAoAsContextFtraceEvent() {
7169 // @@protoc_insertion_point(destructor:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7170 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
7171 (void)arena;
7172 return;
7173 }
7174 SharedDtor();
7175 }
7176
SharedDtor()7177 inline void RotatorBwAoAsContextFtraceEvent::SharedDtor() {
7178 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
7179 }
7180
SetCachedSize(int size) const7181 void RotatorBwAoAsContextFtraceEvent::SetCachedSize(int size) const {
7182 _impl_._cached_size_.Set(size);
7183 }
7184
Clear()7185 void RotatorBwAoAsContextFtraceEvent::Clear() {
7186 // @@protoc_insertion_point(message_clear_start:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7187 ::uint32_t cached_has_bits = 0;
7188 // Prevent compiler warnings about cached_has_bits being unused
7189 (void) cached_has_bits;
7190
7191 _impl_.state_ = 0u;
7192 _impl_._has_bits_.Clear();
7193 _internal_metadata_.Clear<std::string>();
7194 }
7195
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)7196 const char* RotatorBwAoAsContextFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
7197 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
7198 _Internal::HasBits has_bits{};
7199 while (!ctx->Done(&ptr)) {
7200 ::uint32_t tag;
7201 ptr = ::_pbi::ReadTag(ptr, &tag);
7202 switch (tag >> 3) {
7203 // optional uint32 state = 1;
7204 case 1:
7205 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
7206 _Internal::set_has_state(&has_bits);
7207 _impl_.state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
7208 CHK_(ptr);
7209 } else {
7210 goto handle_unusual;
7211 }
7212 continue;
7213 default:
7214 goto handle_unusual;
7215 } // switch
7216 handle_unusual:
7217 if ((tag == 0) || ((tag & 7) == 4)) {
7218 CHK_(ptr);
7219 ctx->SetLastTag(tag);
7220 goto message_done;
7221 }
7222 ptr = UnknownFieldParse(
7223 tag,
7224 _internal_metadata_.mutable_unknown_fields<std::string>(),
7225 ptr, ctx);
7226 CHK_(ptr != nullptr);
7227 } // while
7228 message_done:
7229 _impl_._has_bits_.Or(has_bits);
7230 return ptr;
7231 failure:
7232 ptr = nullptr;
7233 goto message_done;
7234 #undef CHK_
7235 }
7236
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const7237 ::uint8_t* RotatorBwAoAsContextFtraceEvent::_InternalSerialize(
7238 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
7239 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7240 ::uint32_t cached_has_bits = 0;
7241 (void) cached_has_bits;
7242
7243 cached_has_bits = _impl_._has_bits_[0];
7244 // optional uint32 state = 1;
7245 if (cached_has_bits & 0x00000001u) {
7246 target = stream->EnsureSpace(target);
7247 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_state(), target);
7248 }
7249
7250 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7251 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
7252 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
7253 }
7254 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7255 return target;
7256 }
7257
ByteSizeLong() const7258 size_t RotatorBwAoAsContextFtraceEvent::ByteSizeLong() const {
7259 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7260 size_t total_size = 0;
7261
7262 ::uint32_t cached_has_bits = 0;
7263 // Prevent compiler warnings about cached_has_bits being unused
7264 (void) cached_has_bits;
7265
7266 // optional uint32 state = 1;
7267 cached_has_bits = _impl_._has_bits_[0];
7268 if (cached_has_bits & 0x00000001u) {
7269 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_state());
7270 }
7271
7272 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
7273 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
7274 }
7275 int cached_size = ::_pbi::ToCachedSize(total_size);
7276 SetCachedSize(cached_size);
7277 return total_size;
7278 }
7279
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)7280 void RotatorBwAoAsContextFtraceEvent::CheckTypeAndMergeFrom(
7281 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
7282 MergeFrom(*::_pbi::DownCast<const RotatorBwAoAsContextFtraceEvent*>(
7283 &from));
7284 }
7285
MergeFrom(const RotatorBwAoAsContextFtraceEvent & from)7286 void RotatorBwAoAsContextFtraceEvent::MergeFrom(const RotatorBwAoAsContextFtraceEvent& from) {
7287 RotatorBwAoAsContextFtraceEvent* const _this = this;
7288 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7289 GOOGLE_DCHECK_NE(&from, _this);
7290 ::uint32_t cached_has_bits = 0;
7291 (void) cached_has_bits;
7292
7293 if (from._internal_has_state()) {
7294 _this->_internal_set_state(from._internal_state());
7295 }
7296 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
7297 }
7298
CopyFrom(const RotatorBwAoAsContextFtraceEvent & from)7299 void RotatorBwAoAsContextFtraceEvent::CopyFrom(const RotatorBwAoAsContextFtraceEvent& from) {
7300 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.RotatorBwAoAsContextFtraceEvent)
7301 if (&from == this) return;
7302 Clear();
7303 MergeFrom(from);
7304 }
7305
IsInitialized() const7306 bool RotatorBwAoAsContextFtraceEvent::IsInitialized() const {
7307 return true;
7308 }
7309
InternalSwap(RotatorBwAoAsContextFtraceEvent * other)7310 void RotatorBwAoAsContextFtraceEvent::InternalSwap(RotatorBwAoAsContextFtraceEvent* other) {
7311 using std::swap;
7312 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
7313 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
7314 swap(_impl_.state_, other->_impl_.state_);
7315 }
7316
GetTypeName() const7317 std::string RotatorBwAoAsContextFtraceEvent::GetTypeName() const {
7318 return "perfetto.protos.RotatorBwAoAsContextFtraceEvent";
7319 }
7320
7321
7322 // @@protoc_insertion_point(namespace_scope)
7323 } // namespace protos
7324 } // namespace perfetto
7325 PROTOBUF_NAMESPACE_OPEN
7326 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCmdKickoffFtraceEvent*
CreateMaybeMessage(Arena * arena)7327 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCmdKickoffFtraceEvent >(Arena* arena) {
7328 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCmdKickoffFtraceEvent >(arena);
7329 }
7330 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCommitFtraceEvent*
CreateMaybeMessage(Arena * arena)7331 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCommitFtraceEvent >(Arena* arena) {
7332 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCommitFtraceEvent >(arena);
7333 }
7334 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpPerfSetOtFtraceEvent*
CreateMaybeMessage(Arena * arena)7335 Arena::CreateMaybeMessage< ::perfetto::protos::MdpPerfSetOtFtraceEvent >(Arena* arena) {
7336 return Arena::CreateMessageInternal< ::perfetto::protos::MdpPerfSetOtFtraceEvent >(arena);
7337 }
7338 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpSsppChangeFtraceEvent*
CreateMaybeMessage(Arena * arena)7339 Arena::CreateMaybeMessage< ::perfetto::protos::MdpSsppChangeFtraceEvent >(Arena* arena) {
7340 return Arena::CreateMessageInternal< ::perfetto::protos::MdpSsppChangeFtraceEvent >(arena);
7341 }
7342 template<> PROTOBUF_NOINLINE ::perfetto::protos::TracingMarkWriteFtraceEvent*
CreateMaybeMessage(Arena * arena)7343 Arena::CreateMaybeMessage< ::perfetto::protos::TracingMarkWriteFtraceEvent >(Arena* arena) {
7344 return Arena::CreateMessageInternal< ::perfetto::protos::TracingMarkWriteFtraceEvent >(arena);
7345 }
7346 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCmdPingpongDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)7347 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCmdPingpongDoneFtraceEvent >(Arena* arena) {
7348 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCmdPingpongDoneFtraceEvent >(arena);
7349 }
7350 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCompareBwFtraceEvent*
CreateMaybeMessage(Arena * arena)7351 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCompareBwFtraceEvent >(Arena* arena) {
7352 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCompareBwFtraceEvent >(arena);
7353 }
7354 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpPerfSetPanicLutsFtraceEvent*
CreateMaybeMessage(Arena * arena)7355 Arena::CreateMaybeMessage< ::perfetto::protos::MdpPerfSetPanicLutsFtraceEvent >(Arena* arena) {
7356 return Arena::CreateMessageInternal< ::perfetto::protos::MdpPerfSetPanicLutsFtraceEvent >(arena);
7357 }
7358 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpSsppSetFtraceEvent*
CreateMaybeMessage(Arena * arena)7359 Arena::CreateMaybeMessage< ::perfetto::protos::MdpSsppSetFtraceEvent >(Arena* arena) {
7360 return Arena::CreateMessageInternal< ::perfetto::protos::MdpSsppSetFtraceEvent >(arena);
7361 }
7362 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCmdReadptrDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)7363 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCmdReadptrDoneFtraceEvent >(Arena* arena) {
7364 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCmdReadptrDoneFtraceEvent >(arena);
7365 }
7366 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpMisrCrcFtraceEvent*
CreateMaybeMessage(Arena * arena)7367 Arena::CreateMaybeMessage< ::perfetto::protos::MdpMisrCrcFtraceEvent >(Arena* arena) {
7368 return Arena::CreateMessageInternal< ::perfetto::protos::MdpMisrCrcFtraceEvent >(arena);
7369 }
7370 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpPerfSetQosLutsFtraceEvent*
CreateMaybeMessage(Arena * arena)7371 Arena::CreateMaybeMessage< ::perfetto::protos::MdpPerfSetQosLutsFtraceEvent >(Arena* arena) {
7372 return Arena::CreateMessageInternal< ::perfetto::protos::MdpPerfSetQosLutsFtraceEvent >(arena);
7373 }
7374 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpTraceCounterFtraceEvent*
CreateMaybeMessage(Arena * arena)7375 Arena::CreateMaybeMessage< ::perfetto::protos::MdpTraceCounterFtraceEvent >(Arena* arena) {
7376 return Arena::CreateMessageInternal< ::perfetto::protos::MdpTraceCounterFtraceEvent >(arena);
7377 }
7378 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCmdReleaseBwFtraceEvent*
CreateMaybeMessage(Arena * arena)7379 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCmdReleaseBwFtraceEvent >(Arena* arena) {
7380 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCmdReleaseBwFtraceEvent >(arena);
7381 }
7382 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpMixerUpdateFtraceEvent*
CreateMaybeMessage(Arena * arena)7383 Arena::CreateMaybeMessage< ::perfetto::protos::MdpMixerUpdateFtraceEvent >(Arena* arena) {
7384 return Arena::CreateMessageInternal< ::perfetto::protos::MdpMixerUpdateFtraceEvent >(arena);
7385 }
7386 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpPerfSetWmLevelsFtraceEvent*
CreateMaybeMessage(Arena * arena)7387 Arena::CreateMaybeMessage< ::perfetto::protos::MdpPerfSetWmLevelsFtraceEvent >(Arena* arena) {
7388 return Arena::CreateMessageInternal< ::perfetto::protos::MdpPerfSetWmLevelsFtraceEvent >(arena);
7389 }
7390 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpVideoUnderrunDoneFtraceEvent*
CreateMaybeMessage(Arena * arena)7391 Arena::CreateMaybeMessage< ::perfetto::protos::MdpVideoUnderrunDoneFtraceEvent >(Arena* arena) {
7392 return Arena::CreateMessageInternal< ::perfetto::protos::MdpVideoUnderrunDoneFtraceEvent >(arena);
7393 }
7394 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpCmdWaitPingpongFtraceEvent*
CreateMaybeMessage(Arena * arena)7395 Arena::CreateMaybeMessage< ::perfetto::protos::MdpCmdWaitPingpongFtraceEvent >(Arena* arena) {
7396 return Arena::CreateMessageInternal< ::perfetto::protos::MdpCmdWaitPingpongFtraceEvent >(arena);
7397 }
7398 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpPerfPrefillCalcFtraceEvent*
CreateMaybeMessage(Arena * arena)7399 Arena::CreateMaybeMessage< ::perfetto::protos::MdpPerfPrefillCalcFtraceEvent >(Arena* arena) {
7400 return Arena::CreateMessageInternal< ::perfetto::protos::MdpPerfPrefillCalcFtraceEvent >(arena);
7401 }
7402 template<> PROTOBUF_NOINLINE ::perfetto::protos::MdpPerfUpdateBusFtraceEvent*
CreateMaybeMessage(Arena * arena)7403 Arena::CreateMaybeMessage< ::perfetto::protos::MdpPerfUpdateBusFtraceEvent >(Arena* arena) {
7404 return Arena::CreateMessageInternal< ::perfetto::protos::MdpPerfUpdateBusFtraceEvent >(arena);
7405 }
7406 template<> PROTOBUF_NOINLINE ::perfetto::protos::RotatorBwAoAsContextFtraceEvent*
CreateMaybeMessage(Arena * arena)7407 Arena::CreateMaybeMessage< ::perfetto::protos::RotatorBwAoAsContextFtraceEvent >(Arena* arena) {
7408 return Arena::CreateMessageInternal< ::perfetto::protos::RotatorBwAoAsContextFtraceEvent >(arena);
7409 }
7410 PROTOBUF_NAMESPACE_CLOSE
7411
7412 // @@protoc_insertion_point(global_scope)
7413 #include <google/protobuf/port_undef.inc>
7414