1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/compaction.proto
3
4 #include "protos/perfetto/trace/ftrace/compaction.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 {
MmCompactionBeginFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR MmCompactionBeginFtraceEvent::MmCompactionBeginFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.zone_start_)*/::uint64_t{0u}
28 , /*decltype(_impl_.migrate_pfn_)*/::uint64_t{0u}
29 , /*decltype(_impl_.free_pfn_)*/::uint64_t{0u}
30 , /*decltype(_impl_.zone_end_)*/::uint64_t{0u}
31 , /*decltype(_impl_.sync_)*/0u} {}
32 struct MmCompactionBeginFtraceEventDefaultTypeInternal {
MmCompactionBeginFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionBeginFtraceEventDefaultTypeInternal33 PROTOBUF_CONSTEXPR MmCompactionBeginFtraceEventDefaultTypeInternal()
34 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionBeginFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionBeginFtraceEventDefaultTypeInternal35 ~MmCompactionBeginFtraceEventDefaultTypeInternal() {}
36 union { // NOLINT(misc-non-private-member-variables-in-classes)
37 MmCompactionBeginFtraceEvent _instance;
38 };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionBeginFtraceEventDefaultTypeInternal _MmCompactionBeginFtraceEvent_default_instance_;
MmCompactionDeferCompactionFtraceEvent(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR MmCompactionDeferCompactionFtraceEvent::MmCompactionDeferCompactionFtraceEvent(
42 ::_pbi::ConstantInitialized): _impl_{
43 /*decltype(_impl_._has_bits_)*/{}
44 , /*decltype(_impl_._cached_size_)*/{}
45 , /*decltype(_impl_.nid_)*/0
46 , /*decltype(_impl_.idx_)*/0u
47 , /*decltype(_impl_.order_)*/0
48 , /*decltype(_impl_.considered_)*/0u
49 , /*decltype(_impl_.defer_shift_)*/0u
50 , /*decltype(_impl_.order_failed_)*/0} {}
51 struct MmCompactionDeferCompactionFtraceEventDefaultTypeInternal {
MmCompactionDeferCompactionFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionDeferCompactionFtraceEventDefaultTypeInternal52 PROTOBUF_CONSTEXPR MmCompactionDeferCompactionFtraceEventDefaultTypeInternal()
53 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionDeferCompactionFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionDeferCompactionFtraceEventDefaultTypeInternal54 ~MmCompactionDeferCompactionFtraceEventDefaultTypeInternal() {}
55 union { // NOLINT(misc-non-private-member-variables-in-classes)
56 MmCompactionDeferCompactionFtraceEvent _instance;
57 };
58 };
59 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionDeferCompactionFtraceEventDefaultTypeInternal _MmCompactionDeferCompactionFtraceEvent_default_instance_;
MmCompactionDeferredFtraceEvent(::_pbi::ConstantInitialized)60 PROTOBUF_CONSTEXPR MmCompactionDeferredFtraceEvent::MmCompactionDeferredFtraceEvent(
61 ::_pbi::ConstantInitialized): _impl_{
62 /*decltype(_impl_._has_bits_)*/{}
63 , /*decltype(_impl_._cached_size_)*/{}
64 , /*decltype(_impl_.nid_)*/0
65 , /*decltype(_impl_.idx_)*/0u
66 , /*decltype(_impl_.order_)*/0
67 , /*decltype(_impl_.considered_)*/0u
68 , /*decltype(_impl_.defer_shift_)*/0u
69 , /*decltype(_impl_.order_failed_)*/0} {}
70 struct MmCompactionDeferredFtraceEventDefaultTypeInternal {
MmCompactionDeferredFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionDeferredFtraceEventDefaultTypeInternal71 PROTOBUF_CONSTEXPR MmCompactionDeferredFtraceEventDefaultTypeInternal()
72 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionDeferredFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionDeferredFtraceEventDefaultTypeInternal73 ~MmCompactionDeferredFtraceEventDefaultTypeInternal() {}
74 union { // NOLINT(misc-non-private-member-variables-in-classes)
75 MmCompactionDeferredFtraceEvent _instance;
76 };
77 };
78 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionDeferredFtraceEventDefaultTypeInternal _MmCompactionDeferredFtraceEvent_default_instance_;
MmCompactionDeferResetFtraceEvent(::_pbi::ConstantInitialized)79 PROTOBUF_CONSTEXPR MmCompactionDeferResetFtraceEvent::MmCompactionDeferResetFtraceEvent(
80 ::_pbi::ConstantInitialized): _impl_{
81 /*decltype(_impl_._has_bits_)*/{}
82 , /*decltype(_impl_._cached_size_)*/{}
83 , /*decltype(_impl_.nid_)*/0
84 , /*decltype(_impl_.idx_)*/0u
85 , /*decltype(_impl_.order_)*/0
86 , /*decltype(_impl_.considered_)*/0u
87 , /*decltype(_impl_.defer_shift_)*/0u
88 , /*decltype(_impl_.order_failed_)*/0} {}
89 struct MmCompactionDeferResetFtraceEventDefaultTypeInternal {
MmCompactionDeferResetFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionDeferResetFtraceEventDefaultTypeInternal90 PROTOBUF_CONSTEXPR MmCompactionDeferResetFtraceEventDefaultTypeInternal()
91 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionDeferResetFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionDeferResetFtraceEventDefaultTypeInternal92 ~MmCompactionDeferResetFtraceEventDefaultTypeInternal() {}
93 union { // NOLINT(misc-non-private-member-variables-in-classes)
94 MmCompactionDeferResetFtraceEvent _instance;
95 };
96 };
97 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionDeferResetFtraceEventDefaultTypeInternal _MmCompactionDeferResetFtraceEvent_default_instance_;
MmCompactionEndFtraceEvent(::_pbi::ConstantInitialized)98 PROTOBUF_CONSTEXPR MmCompactionEndFtraceEvent::MmCompactionEndFtraceEvent(
99 ::_pbi::ConstantInitialized): _impl_{
100 /*decltype(_impl_._has_bits_)*/{}
101 , /*decltype(_impl_._cached_size_)*/{}
102 , /*decltype(_impl_.zone_start_)*/::uint64_t{0u}
103 , /*decltype(_impl_.migrate_pfn_)*/::uint64_t{0u}
104 , /*decltype(_impl_.free_pfn_)*/::uint64_t{0u}
105 , /*decltype(_impl_.zone_end_)*/::uint64_t{0u}
106 , /*decltype(_impl_.sync_)*/0u
107 , /*decltype(_impl_.status_)*/0} {}
108 struct MmCompactionEndFtraceEventDefaultTypeInternal {
MmCompactionEndFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionEndFtraceEventDefaultTypeInternal109 PROTOBUF_CONSTEXPR MmCompactionEndFtraceEventDefaultTypeInternal()
110 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionEndFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionEndFtraceEventDefaultTypeInternal111 ~MmCompactionEndFtraceEventDefaultTypeInternal() {}
112 union { // NOLINT(misc-non-private-member-variables-in-classes)
113 MmCompactionEndFtraceEvent _instance;
114 };
115 };
116 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionEndFtraceEventDefaultTypeInternal _MmCompactionEndFtraceEvent_default_instance_;
MmCompactionFinishedFtraceEvent(::_pbi::ConstantInitialized)117 PROTOBUF_CONSTEXPR MmCompactionFinishedFtraceEvent::MmCompactionFinishedFtraceEvent(
118 ::_pbi::ConstantInitialized): _impl_{
119 /*decltype(_impl_._has_bits_)*/{}
120 , /*decltype(_impl_._cached_size_)*/{}
121 , /*decltype(_impl_.nid_)*/0
122 , /*decltype(_impl_.idx_)*/0u
123 , /*decltype(_impl_.order_)*/0
124 , /*decltype(_impl_.ret_)*/0} {}
125 struct MmCompactionFinishedFtraceEventDefaultTypeInternal {
MmCompactionFinishedFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionFinishedFtraceEventDefaultTypeInternal126 PROTOBUF_CONSTEXPR MmCompactionFinishedFtraceEventDefaultTypeInternal()
127 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionFinishedFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionFinishedFtraceEventDefaultTypeInternal128 ~MmCompactionFinishedFtraceEventDefaultTypeInternal() {}
129 union { // NOLINT(misc-non-private-member-variables-in-classes)
130 MmCompactionFinishedFtraceEvent _instance;
131 };
132 };
133 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionFinishedFtraceEventDefaultTypeInternal _MmCompactionFinishedFtraceEvent_default_instance_;
MmCompactionIsolateFreepagesFtraceEvent(::_pbi::ConstantInitialized)134 PROTOBUF_CONSTEXPR MmCompactionIsolateFreepagesFtraceEvent::MmCompactionIsolateFreepagesFtraceEvent(
135 ::_pbi::ConstantInitialized): _impl_{
136 /*decltype(_impl_._has_bits_)*/{}
137 , /*decltype(_impl_._cached_size_)*/{}
138 , /*decltype(_impl_.start_pfn_)*/::uint64_t{0u}
139 , /*decltype(_impl_.end_pfn_)*/::uint64_t{0u}
140 , /*decltype(_impl_.nr_scanned_)*/::uint64_t{0u}
141 , /*decltype(_impl_.nr_taken_)*/::uint64_t{0u}} {}
142 struct MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternal {
MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternal143 PROTOBUF_CONSTEXPR MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternal()
144 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternal145 ~MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternal() {}
146 union { // NOLINT(misc-non-private-member-variables-in-classes)
147 MmCompactionIsolateFreepagesFtraceEvent _instance;
148 };
149 };
150 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionIsolateFreepagesFtraceEventDefaultTypeInternal _MmCompactionIsolateFreepagesFtraceEvent_default_instance_;
MmCompactionIsolateMigratepagesFtraceEvent(::_pbi::ConstantInitialized)151 PROTOBUF_CONSTEXPR MmCompactionIsolateMigratepagesFtraceEvent::MmCompactionIsolateMigratepagesFtraceEvent(
152 ::_pbi::ConstantInitialized): _impl_{
153 /*decltype(_impl_._has_bits_)*/{}
154 , /*decltype(_impl_._cached_size_)*/{}
155 , /*decltype(_impl_.start_pfn_)*/::uint64_t{0u}
156 , /*decltype(_impl_.end_pfn_)*/::uint64_t{0u}
157 , /*decltype(_impl_.nr_scanned_)*/::uint64_t{0u}
158 , /*decltype(_impl_.nr_taken_)*/::uint64_t{0u}} {}
159 struct MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternal {
MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternal160 PROTOBUF_CONSTEXPR MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternal()
161 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternal162 ~MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternal() {}
163 union { // NOLINT(misc-non-private-member-variables-in-classes)
164 MmCompactionIsolateMigratepagesFtraceEvent _instance;
165 };
166 };
167 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionIsolateMigratepagesFtraceEventDefaultTypeInternal _MmCompactionIsolateMigratepagesFtraceEvent_default_instance_;
MmCompactionKcompactdSleepFtraceEvent(::_pbi::ConstantInitialized)168 PROTOBUF_CONSTEXPR MmCompactionKcompactdSleepFtraceEvent::MmCompactionKcompactdSleepFtraceEvent(
169 ::_pbi::ConstantInitialized): _impl_{
170 /*decltype(_impl_._has_bits_)*/{}
171 , /*decltype(_impl_._cached_size_)*/{}
172 , /*decltype(_impl_.nid_)*/0} {}
173 struct MmCompactionKcompactdSleepFtraceEventDefaultTypeInternal {
MmCompactionKcompactdSleepFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionKcompactdSleepFtraceEventDefaultTypeInternal174 PROTOBUF_CONSTEXPR MmCompactionKcompactdSleepFtraceEventDefaultTypeInternal()
175 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionKcompactdSleepFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionKcompactdSleepFtraceEventDefaultTypeInternal176 ~MmCompactionKcompactdSleepFtraceEventDefaultTypeInternal() {}
177 union { // NOLINT(misc-non-private-member-variables-in-classes)
178 MmCompactionKcompactdSleepFtraceEvent _instance;
179 };
180 };
181 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionKcompactdSleepFtraceEventDefaultTypeInternal _MmCompactionKcompactdSleepFtraceEvent_default_instance_;
MmCompactionKcompactdWakeFtraceEvent(::_pbi::ConstantInitialized)182 PROTOBUF_CONSTEXPR MmCompactionKcompactdWakeFtraceEvent::MmCompactionKcompactdWakeFtraceEvent(
183 ::_pbi::ConstantInitialized): _impl_{
184 /*decltype(_impl_._has_bits_)*/{}
185 , /*decltype(_impl_._cached_size_)*/{}
186 , /*decltype(_impl_.nid_)*/0
187 , /*decltype(_impl_.order_)*/0
188 , /*decltype(_impl_.classzone_idx_)*/0u
189 , /*decltype(_impl_.highest_zoneidx_)*/0u} {}
190 struct MmCompactionKcompactdWakeFtraceEventDefaultTypeInternal {
MmCompactionKcompactdWakeFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionKcompactdWakeFtraceEventDefaultTypeInternal191 PROTOBUF_CONSTEXPR MmCompactionKcompactdWakeFtraceEventDefaultTypeInternal()
192 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionKcompactdWakeFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionKcompactdWakeFtraceEventDefaultTypeInternal193 ~MmCompactionKcompactdWakeFtraceEventDefaultTypeInternal() {}
194 union { // NOLINT(misc-non-private-member-variables-in-classes)
195 MmCompactionKcompactdWakeFtraceEvent _instance;
196 };
197 };
198 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionKcompactdWakeFtraceEventDefaultTypeInternal _MmCompactionKcompactdWakeFtraceEvent_default_instance_;
MmCompactionMigratepagesFtraceEvent(::_pbi::ConstantInitialized)199 PROTOBUF_CONSTEXPR MmCompactionMigratepagesFtraceEvent::MmCompactionMigratepagesFtraceEvent(
200 ::_pbi::ConstantInitialized): _impl_{
201 /*decltype(_impl_._has_bits_)*/{}
202 , /*decltype(_impl_._cached_size_)*/{}
203 , /*decltype(_impl_.nr_migrated_)*/::uint64_t{0u}
204 , /*decltype(_impl_.nr_failed_)*/::uint64_t{0u}} {}
205 struct MmCompactionMigratepagesFtraceEventDefaultTypeInternal {
MmCompactionMigratepagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionMigratepagesFtraceEventDefaultTypeInternal206 PROTOBUF_CONSTEXPR MmCompactionMigratepagesFtraceEventDefaultTypeInternal()
207 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionMigratepagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionMigratepagesFtraceEventDefaultTypeInternal208 ~MmCompactionMigratepagesFtraceEventDefaultTypeInternal() {}
209 union { // NOLINT(misc-non-private-member-variables-in-classes)
210 MmCompactionMigratepagesFtraceEvent _instance;
211 };
212 };
213 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionMigratepagesFtraceEventDefaultTypeInternal _MmCompactionMigratepagesFtraceEvent_default_instance_;
MmCompactionSuitableFtraceEvent(::_pbi::ConstantInitialized)214 PROTOBUF_CONSTEXPR MmCompactionSuitableFtraceEvent::MmCompactionSuitableFtraceEvent(
215 ::_pbi::ConstantInitialized): _impl_{
216 /*decltype(_impl_._has_bits_)*/{}
217 , /*decltype(_impl_._cached_size_)*/{}
218 , /*decltype(_impl_.nid_)*/0
219 , /*decltype(_impl_.idx_)*/0u
220 , /*decltype(_impl_.order_)*/0
221 , /*decltype(_impl_.ret_)*/0} {}
222 struct MmCompactionSuitableFtraceEventDefaultTypeInternal {
MmCompactionSuitableFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionSuitableFtraceEventDefaultTypeInternal223 PROTOBUF_CONSTEXPR MmCompactionSuitableFtraceEventDefaultTypeInternal()
224 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionSuitableFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionSuitableFtraceEventDefaultTypeInternal225 ~MmCompactionSuitableFtraceEventDefaultTypeInternal() {}
226 union { // NOLINT(misc-non-private-member-variables-in-classes)
227 MmCompactionSuitableFtraceEvent _instance;
228 };
229 };
230 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionSuitableFtraceEventDefaultTypeInternal _MmCompactionSuitableFtraceEvent_default_instance_;
MmCompactionTryToCompactPagesFtraceEvent(::_pbi::ConstantInitialized)231 PROTOBUF_CONSTEXPR MmCompactionTryToCompactPagesFtraceEvent::MmCompactionTryToCompactPagesFtraceEvent(
232 ::_pbi::ConstantInitialized): _impl_{
233 /*decltype(_impl_._has_bits_)*/{}
234 , /*decltype(_impl_._cached_size_)*/{}
235 , /*decltype(_impl_.order_)*/0
236 , /*decltype(_impl_.gfp_mask_)*/0u
237 , /*decltype(_impl_.mode_)*/0u
238 , /*decltype(_impl_.prio_)*/0} {}
239 struct MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternal {
MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternal240 PROTOBUF_CONSTEXPR MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternal()
241 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternal242 ~MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternal() {}
243 union { // NOLINT(misc-non-private-member-variables-in-classes)
244 MmCompactionTryToCompactPagesFtraceEvent _instance;
245 };
246 };
247 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionTryToCompactPagesFtraceEventDefaultTypeInternal _MmCompactionTryToCompactPagesFtraceEvent_default_instance_;
MmCompactionWakeupKcompactdFtraceEvent(::_pbi::ConstantInitialized)248 PROTOBUF_CONSTEXPR MmCompactionWakeupKcompactdFtraceEvent::MmCompactionWakeupKcompactdFtraceEvent(
249 ::_pbi::ConstantInitialized): _impl_{
250 /*decltype(_impl_._has_bits_)*/{}
251 , /*decltype(_impl_._cached_size_)*/{}
252 , /*decltype(_impl_.nid_)*/0
253 , /*decltype(_impl_.order_)*/0
254 , /*decltype(_impl_.classzone_idx_)*/0u
255 , /*decltype(_impl_.highest_zoneidx_)*/0u} {}
256 struct MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternal {
MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternal257 PROTOBUF_CONSTEXPR MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternal()
258 : _instance(::_pbi::ConstantInitialized{}) {}
~MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternalperfetto::protos::MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternal259 ~MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternal() {}
260 union { // NOLINT(misc-non-private-member-variables-in-classes)
261 MmCompactionWakeupKcompactdFtraceEvent _instance;
262 };
263 };
264 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmCompactionWakeupKcompactdFtraceEventDefaultTypeInternal _MmCompactionWakeupKcompactdFtraceEvent_default_instance_;
265 } // namespace protos
266 } // namespace perfetto
267 namespace perfetto {
268 namespace protos {
269
270 // ===================================================================
271
272 class MmCompactionBeginFtraceEvent::_Internal {
273 public:
274 using HasBits = decltype(std::declval<MmCompactionBeginFtraceEvent>()._impl_._has_bits_);
set_has_zone_start(HasBits * has_bits)275 static void set_has_zone_start(HasBits* has_bits) {
276 (*has_bits)[0] |= 1u;
277 }
set_has_migrate_pfn(HasBits * has_bits)278 static void set_has_migrate_pfn(HasBits* has_bits) {
279 (*has_bits)[0] |= 2u;
280 }
set_has_free_pfn(HasBits * has_bits)281 static void set_has_free_pfn(HasBits* has_bits) {
282 (*has_bits)[0] |= 4u;
283 }
set_has_zone_end(HasBits * has_bits)284 static void set_has_zone_end(HasBits* has_bits) {
285 (*has_bits)[0] |= 8u;
286 }
set_has_sync(HasBits * has_bits)287 static void set_has_sync(HasBits* has_bits) {
288 (*has_bits)[0] |= 16u;
289 }
290 };
291
MmCompactionBeginFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)292 MmCompactionBeginFtraceEvent::MmCompactionBeginFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
293 bool is_message_owned)
294 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
295 SharedCtor(arena, is_message_owned);
296 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionBeginFtraceEvent)
297 }
MmCompactionBeginFtraceEvent(const MmCompactionBeginFtraceEvent & from)298 MmCompactionBeginFtraceEvent::MmCompactionBeginFtraceEvent(const MmCompactionBeginFtraceEvent& from)
299 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
300 MmCompactionBeginFtraceEvent* const _this = this; (void)_this;
301 new (&_impl_) Impl_{
302 decltype(_impl_._has_bits_){from._impl_._has_bits_}
303 , /*decltype(_impl_._cached_size_)*/{}
304 , decltype(_impl_.zone_start_){}
305 , decltype(_impl_.migrate_pfn_){}
306 , decltype(_impl_.free_pfn_){}
307 , decltype(_impl_.zone_end_){}
308 , decltype(_impl_.sync_){}};
309
310 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
311 ::memcpy(&_impl_.zone_start_, &from._impl_.zone_start_,
312 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.sync_) -
313 reinterpret_cast<char*>(&_impl_.zone_start_)) + sizeof(_impl_.sync_));
314 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionBeginFtraceEvent)
315 }
316
SharedCtor(::_pb::Arena * arena,bool is_message_owned)317 inline void MmCompactionBeginFtraceEvent::SharedCtor(
318 ::_pb::Arena* arena, bool is_message_owned) {
319 (void)arena;
320 (void)is_message_owned;
321 new (&_impl_) Impl_{
322 decltype(_impl_._has_bits_){}
323 , /*decltype(_impl_._cached_size_)*/{}
324 , decltype(_impl_.zone_start_){::uint64_t{0u}}
325 , decltype(_impl_.migrate_pfn_){::uint64_t{0u}}
326 , decltype(_impl_.free_pfn_){::uint64_t{0u}}
327 , decltype(_impl_.zone_end_){::uint64_t{0u}}
328 , decltype(_impl_.sync_){0u}
329 };
330 }
331
~MmCompactionBeginFtraceEvent()332 MmCompactionBeginFtraceEvent::~MmCompactionBeginFtraceEvent() {
333 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionBeginFtraceEvent)
334 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
335 (void)arena;
336 return;
337 }
338 SharedDtor();
339 }
340
SharedDtor()341 inline void MmCompactionBeginFtraceEvent::SharedDtor() {
342 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
343 }
344
SetCachedSize(int size) const345 void MmCompactionBeginFtraceEvent::SetCachedSize(int size) const {
346 _impl_._cached_size_.Set(size);
347 }
348
Clear()349 void MmCompactionBeginFtraceEvent::Clear() {
350 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionBeginFtraceEvent)
351 ::uint32_t cached_has_bits = 0;
352 // Prevent compiler warnings about cached_has_bits being unused
353 (void) cached_has_bits;
354
355 cached_has_bits = _impl_._has_bits_[0];
356 if (cached_has_bits & 0x0000001fu) {
357 ::memset(&_impl_.zone_start_, 0, static_cast<size_t>(
358 reinterpret_cast<char*>(&_impl_.sync_) -
359 reinterpret_cast<char*>(&_impl_.zone_start_)) + sizeof(_impl_.sync_));
360 }
361 _impl_._has_bits_.Clear();
362 _internal_metadata_.Clear<std::string>();
363 }
364
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)365 const char* MmCompactionBeginFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
366 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
367 _Internal::HasBits has_bits{};
368 while (!ctx->Done(&ptr)) {
369 ::uint32_t tag;
370 ptr = ::_pbi::ReadTag(ptr, &tag);
371 switch (tag >> 3) {
372 // optional uint64 zone_start = 1;
373 case 1:
374 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
375 _Internal::set_has_zone_start(&has_bits);
376 _impl_.zone_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
377 CHK_(ptr);
378 } else {
379 goto handle_unusual;
380 }
381 continue;
382 // optional uint64 migrate_pfn = 2;
383 case 2:
384 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
385 _Internal::set_has_migrate_pfn(&has_bits);
386 _impl_.migrate_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
387 CHK_(ptr);
388 } else {
389 goto handle_unusual;
390 }
391 continue;
392 // optional uint64 free_pfn = 3;
393 case 3:
394 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
395 _Internal::set_has_free_pfn(&has_bits);
396 _impl_.free_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
397 CHK_(ptr);
398 } else {
399 goto handle_unusual;
400 }
401 continue;
402 // optional uint64 zone_end = 4;
403 case 4:
404 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
405 _Internal::set_has_zone_end(&has_bits);
406 _impl_.zone_end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
407 CHK_(ptr);
408 } else {
409 goto handle_unusual;
410 }
411 continue;
412 // optional uint32 sync = 5;
413 case 5:
414 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
415 _Internal::set_has_sync(&has_bits);
416 _impl_.sync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
417 CHK_(ptr);
418 } else {
419 goto handle_unusual;
420 }
421 continue;
422 default:
423 goto handle_unusual;
424 } // switch
425 handle_unusual:
426 if ((tag == 0) || ((tag & 7) == 4)) {
427 CHK_(ptr);
428 ctx->SetLastTag(tag);
429 goto message_done;
430 }
431 ptr = UnknownFieldParse(
432 tag,
433 _internal_metadata_.mutable_unknown_fields<std::string>(),
434 ptr, ctx);
435 CHK_(ptr != nullptr);
436 } // while
437 message_done:
438 _impl_._has_bits_.Or(has_bits);
439 return ptr;
440 failure:
441 ptr = nullptr;
442 goto message_done;
443 #undef CHK_
444 }
445
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const446 ::uint8_t* MmCompactionBeginFtraceEvent::_InternalSerialize(
447 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
448 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionBeginFtraceEvent)
449 ::uint32_t cached_has_bits = 0;
450 (void) cached_has_bits;
451
452 cached_has_bits = _impl_._has_bits_[0];
453 // optional uint64 zone_start = 1;
454 if (cached_has_bits & 0x00000001u) {
455 target = stream->EnsureSpace(target);
456 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_zone_start(), target);
457 }
458
459 // optional uint64 migrate_pfn = 2;
460 if (cached_has_bits & 0x00000002u) {
461 target = stream->EnsureSpace(target);
462 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_migrate_pfn(), target);
463 }
464
465 // optional uint64 free_pfn = 3;
466 if (cached_has_bits & 0x00000004u) {
467 target = stream->EnsureSpace(target);
468 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_free_pfn(), target);
469 }
470
471 // optional uint64 zone_end = 4;
472 if (cached_has_bits & 0x00000008u) {
473 target = stream->EnsureSpace(target);
474 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_zone_end(), target);
475 }
476
477 // optional uint32 sync = 5;
478 if (cached_has_bits & 0x00000010u) {
479 target = stream->EnsureSpace(target);
480 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_sync(), target);
481 }
482
483 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
484 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
485 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
486 }
487 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionBeginFtraceEvent)
488 return target;
489 }
490
ByteSizeLong() const491 size_t MmCompactionBeginFtraceEvent::ByteSizeLong() const {
492 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionBeginFtraceEvent)
493 size_t total_size = 0;
494
495 ::uint32_t cached_has_bits = 0;
496 // Prevent compiler warnings about cached_has_bits being unused
497 (void) cached_has_bits;
498
499 cached_has_bits = _impl_._has_bits_[0];
500 if (cached_has_bits & 0x0000001fu) {
501 // optional uint64 zone_start = 1;
502 if (cached_has_bits & 0x00000001u) {
503 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_zone_start());
504 }
505
506 // optional uint64 migrate_pfn = 2;
507 if (cached_has_bits & 0x00000002u) {
508 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_migrate_pfn());
509 }
510
511 // optional uint64 free_pfn = 3;
512 if (cached_has_bits & 0x00000004u) {
513 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_free_pfn());
514 }
515
516 // optional uint64 zone_end = 4;
517 if (cached_has_bits & 0x00000008u) {
518 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_zone_end());
519 }
520
521 // optional uint32 sync = 5;
522 if (cached_has_bits & 0x00000010u) {
523 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sync());
524 }
525
526 }
527 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
528 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
529 }
530 int cached_size = ::_pbi::ToCachedSize(total_size);
531 SetCachedSize(cached_size);
532 return total_size;
533 }
534
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)535 void MmCompactionBeginFtraceEvent::CheckTypeAndMergeFrom(
536 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
537 MergeFrom(*::_pbi::DownCast<const MmCompactionBeginFtraceEvent*>(
538 &from));
539 }
540
MergeFrom(const MmCompactionBeginFtraceEvent & from)541 void MmCompactionBeginFtraceEvent::MergeFrom(const MmCompactionBeginFtraceEvent& from) {
542 MmCompactionBeginFtraceEvent* const _this = this;
543 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionBeginFtraceEvent)
544 GOOGLE_DCHECK_NE(&from, _this);
545 ::uint32_t cached_has_bits = 0;
546 (void) cached_has_bits;
547
548 cached_has_bits = from._impl_._has_bits_[0];
549 if (cached_has_bits & 0x0000001fu) {
550 if (cached_has_bits & 0x00000001u) {
551 _this->_impl_.zone_start_ = from._impl_.zone_start_;
552 }
553 if (cached_has_bits & 0x00000002u) {
554 _this->_impl_.migrate_pfn_ = from._impl_.migrate_pfn_;
555 }
556 if (cached_has_bits & 0x00000004u) {
557 _this->_impl_.free_pfn_ = from._impl_.free_pfn_;
558 }
559 if (cached_has_bits & 0x00000008u) {
560 _this->_impl_.zone_end_ = from._impl_.zone_end_;
561 }
562 if (cached_has_bits & 0x00000010u) {
563 _this->_impl_.sync_ = from._impl_.sync_;
564 }
565 _this->_impl_._has_bits_[0] |= cached_has_bits;
566 }
567 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
568 }
569
CopyFrom(const MmCompactionBeginFtraceEvent & from)570 void MmCompactionBeginFtraceEvent::CopyFrom(const MmCompactionBeginFtraceEvent& from) {
571 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionBeginFtraceEvent)
572 if (&from == this) return;
573 Clear();
574 MergeFrom(from);
575 }
576
IsInitialized() const577 bool MmCompactionBeginFtraceEvent::IsInitialized() const {
578 return true;
579 }
580
InternalSwap(MmCompactionBeginFtraceEvent * other)581 void MmCompactionBeginFtraceEvent::InternalSwap(MmCompactionBeginFtraceEvent* other) {
582 using std::swap;
583 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
584 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
585 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
586 PROTOBUF_FIELD_OFFSET(MmCompactionBeginFtraceEvent, _impl_.sync_)
587 + sizeof(MmCompactionBeginFtraceEvent::_impl_.sync_) // NOLINT
588 - PROTOBUF_FIELD_OFFSET(MmCompactionBeginFtraceEvent, _impl_.zone_start_)>(
589 reinterpret_cast<char*>(&_impl_.zone_start_),
590 reinterpret_cast<char*>(&other->_impl_.zone_start_));
591 }
592
GetTypeName() const593 std::string MmCompactionBeginFtraceEvent::GetTypeName() const {
594 return "perfetto.protos.MmCompactionBeginFtraceEvent";
595 }
596
597
598 // ===================================================================
599
600 class MmCompactionDeferCompactionFtraceEvent::_Internal {
601 public:
602 using HasBits = decltype(std::declval<MmCompactionDeferCompactionFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)603 static void set_has_nid(HasBits* has_bits) {
604 (*has_bits)[0] |= 1u;
605 }
set_has_idx(HasBits * has_bits)606 static void set_has_idx(HasBits* has_bits) {
607 (*has_bits)[0] |= 2u;
608 }
set_has_order(HasBits * has_bits)609 static void set_has_order(HasBits* has_bits) {
610 (*has_bits)[0] |= 4u;
611 }
set_has_considered(HasBits * has_bits)612 static void set_has_considered(HasBits* has_bits) {
613 (*has_bits)[0] |= 8u;
614 }
set_has_defer_shift(HasBits * has_bits)615 static void set_has_defer_shift(HasBits* has_bits) {
616 (*has_bits)[0] |= 16u;
617 }
set_has_order_failed(HasBits * has_bits)618 static void set_has_order_failed(HasBits* has_bits) {
619 (*has_bits)[0] |= 32u;
620 }
621 };
622
MmCompactionDeferCompactionFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)623 MmCompactionDeferCompactionFtraceEvent::MmCompactionDeferCompactionFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
624 bool is_message_owned)
625 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
626 SharedCtor(arena, is_message_owned);
627 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
628 }
MmCompactionDeferCompactionFtraceEvent(const MmCompactionDeferCompactionFtraceEvent & from)629 MmCompactionDeferCompactionFtraceEvent::MmCompactionDeferCompactionFtraceEvent(const MmCompactionDeferCompactionFtraceEvent& from)
630 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
631 MmCompactionDeferCompactionFtraceEvent* const _this = this; (void)_this;
632 new (&_impl_) Impl_{
633 decltype(_impl_._has_bits_){from._impl_._has_bits_}
634 , /*decltype(_impl_._cached_size_)*/{}
635 , decltype(_impl_.nid_){}
636 , decltype(_impl_.idx_){}
637 , decltype(_impl_.order_){}
638 , decltype(_impl_.considered_){}
639 , decltype(_impl_.defer_shift_){}
640 , decltype(_impl_.order_failed_){}};
641
642 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
643 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
644 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.order_failed_) -
645 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.order_failed_));
646 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
647 }
648
SharedCtor(::_pb::Arena * arena,bool is_message_owned)649 inline void MmCompactionDeferCompactionFtraceEvent::SharedCtor(
650 ::_pb::Arena* arena, bool is_message_owned) {
651 (void)arena;
652 (void)is_message_owned;
653 new (&_impl_) Impl_{
654 decltype(_impl_._has_bits_){}
655 , /*decltype(_impl_._cached_size_)*/{}
656 , decltype(_impl_.nid_){0}
657 , decltype(_impl_.idx_){0u}
658 , decltype(_impl_.order_){0}
659 , decltype(_impl_.considered_){0u}
660 , decltype(_impl_.defer_shift_){0u}
661 , decltype(_impl_.order_failed_){0}
662 };
663 }
664
~MmCompactionDeferCompactionFtraceEvent()665 MmCompactionDeferCompactionFtraceEvent::~MmCompactionDeferCompactionFtraceEvent() {
666 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
667 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
668 (void)arena;
669 return;
670 }
671 SharedDtor();
672 }
673
SharedDtor()674 inline void MmCompactionDeferCompactionFtraceEvent::SharedDtor() {
675 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
676 }
677
SetCachedSize(int size) const678 void MmCompactionDeferCompactionFtraceEvent::SetCachedSize(int size) const {
679 _impl_._cached_size_.Set(size);
680 }
681
Clear()682 void MmCompactionDeferCompactionFtraceEvent::Clear() {
683 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
684 ::uint32_t cached_has_bits = 0;
685 // Prevent compiler warnings about cached_has_bits being unused
686 (void) cached_has_bits;
687
688 cached_has_bits = _impl_._has_bits_[0];
689 if (cached_has_bits & 0x0000003fu) {
690 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
691 reinterpret_cast<char*>(&_impl_.order_failed_) -
692 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.order_failed_));
693 }
694 _impl_._has_bits_.Clear();
695 _internal_metadata_.Clear<std::string>();
696 }
697
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)698 const char* MmCompactionDeferCompactionFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
699 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
700 _Internal::HasBits has_bits{};
701 while (!ctx->Done(&ptr)) {
702 ::uint32_t tag;
703 ptr = ::_pbi::ReadTag(ptr, &tag);
704 switch (tag >> 3) {
705 // optional int32 nid = 1;
706 case 1:
707 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
708 _Internal::set_has_nid(&has_bits);
709 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
710 CHK_(ptr);
711 } else {
712 goto handle_unusual;
713 }
714 continue;
715 // optional uint32 idx = 2;
716 case 2:
717 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
718 _Internal::set_has_idx(&has_bits);
719 _impl_.idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
720 CHK_(ptr);
721 } else {
722 goto handle_unusual;
723 }
724 continue;
725 // optional int32 order = 3;
726 case 3:
727 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
728 _Internal::set_has_order(&has_bits);
729 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
730 CHK_(ptr);
731 } else {
732 goto handle_unusual;
733 }
734 continue;
735 // optional uint32 considered = 4;
736 case 4:
737 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
738 _Internal::set_has_considered(&has_bits);
739 _impl_.considered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
740 CHK_(ptr);
741 } else {
742 goto handle_unusual;
743 }
744 continue;
745 // optional uint32 defer_shift = 5;
746 case 5:
747 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
748 _Internal::set_has_defer_shift(&has_bits);
749 _impl_.defer_shift_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
750 CHK_(ptr);
751 } else {
752 goto handle_unusual;
753 }
754 continue;
755 // optional int32 order_failed = 6;
756 case 6:
757 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
758 _Internal::set_has_order_failed(&has_bits);
759 _impl_.order_failed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
760 CHK_(ptr);
761 } else {
762 goto handle_unusual;
763 }
764 continue;
765 default:
766 goto handle_unusual;
767 } // switch
768 handle_unusual:
769 if ((tag == 0) || ((tag & 7) == 4)) {
770 CHK_(ptr);
771 ctx->SetLastTag(tag);
772 goto message_done;
773 }
774 ptr = UnknownFieldParse(
775 tag,
776 _internal_metadata_.mutable_unknown_fields<std::string>(),
777 ptr, ctx);
778 CHK_(ptr != nullptr);
779 } // while
780 message_done:
781 _impl_._has_bits_.Or(has_bits);
782 return ptr;
783 failure:
784 ptr = nullptr;
785 goto message_done;
786 #undef CHK_
787 }
788
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const789 ::uint8_t* MmCompactionDeferCompactionFtraceEvent::_InternalSerialize(
790 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
791 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
792 ::uint32_t cached_has_bits = 0;
793 (void) cached_has_bits;
794
795 cached_has_bits = _impl_._has_bits_[0];
796 // optional int32 nid = 1;
797 if (cached_has_bits & 0x00000001u) {
798 target = stream->EnsureSpace(target);
799 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
800 }
801
802 // optional uint32 idx = 2;
803 if (cached_has_bits & 0x00000002u) {
804 target = stream->EnsureSpace(target);
805 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_idx(), target);
806 }
807
808 // optional int32 order = 3;
809 if (cached_has_bits & 0x00000004u) {
810 target = stream->EnsureSpace(target);
811 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_order(), target);
812 }
813
814 // optional uint32 considered = 4;
815 if (cached_has_bits & 0x00000008u) {
816 target = stream->EnsureSpace(target);
817 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_considered(), target);
818 }
819
820 // optional uint32 defer_shift = 5;
821 if (cached_has_bits & 0x00000010u) {
822 target = stream->EnsureSpace(target);
823 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_defer_shift(), target);
824 }
825
826 // optional int32 order_failed = 6;
827 if (cached_has_bits & 0x00000020u) {
828 target = stream->EnsureSpace(target);
829 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_order_failed(), target);
830 }
831
832 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
833 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
834 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
835 }
836 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
837 return target;
838 }
839
ByteSizeLong() const840 size_t MmCompactionDeferCompactionFtraceEvent::ByteSizeLong() const {
841 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
842 size_t total_size = 0;
843
844 ::uint32_t cached_has_bits = 0;
845 // Prevent compiler warnings about cached_has_bits being unused
846 (void) cached_has_bits;
847
848 cached_has_bits = _impl_._has_bits_[0];
849 if (cached_has_bits & 0x0000003fu) {
850 // optional int32 nid = 1;
851 if (cached_has_bits & 0x00000001u) {
852 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
853 }
854
855 // optional uint32 idx = 2;
856 if (cached_has_bits & 0x00000002u) {
857 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_idx());
858 }
859
860 // optional int32 order = 3;
861 if (cached_has_bits & 0x00000004u) {
862 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
863 }
864
865 // optional uint32 considered = 4;
866 if (cached_has_bits & 0x00000008u) {
867 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_considered());
868 }
869
870 // optional uint32 defer_shift = 5;
871 if (cached_has_bits & 0x00000010u) {
872 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_defer_shift());
873 }
874
875 // optional int32 order_failed = 6;
876 if (cached_has_bits & 0x00000020u) {
877 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order_failed());
878 }
879
880 }
881 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
882 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
883 }
884 int cached_size = ::_pbi::ToCachedSize(total_size);
885 SetCachedSize(cached_size);
886 return total_size;
887 }
888
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)889 void MmCompactionDeferCompactionFtraceEvent::CheckTypeAndMergeFrom(
890 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
891 MergeFrom(*::_pbi::DownCast<const MmCompactionDeferCompactionFtraceEvent*>(
892 &from));
893 }
894
MergeFrom(const MmCompactionDeferCompactionFtraceEvent & from)895 void MmCompactionDeferCompactionFtraceEvent::MergeFrom(const MmCompactionDeferCompactionFtraceEvent& from) {
896 MmCompactionDeferCompactionFtraceEvent* const _this = this;
897 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
898 GOOGLE_DCHECK_NE(&from, _this);
899 ::uint32_t cached_has_bits = 0;
900 (void) cached_has_bits;
901
902 cached_has_bits = from._impl_._has_bits_[0];
903 if (cached_has_bits & 0x0000003fu) {
904 if (cached_has_bits & 0x00000001u) {
905 _this->_impl_.nid_ = from._impl_.nid_;
906 }
907 if (cached_has_bits & 0x00000002u) {
908 _this->_impl_.idx_ = from._impl_.idx_;
909 }
910 if (cached_has_bits & 0x00000004u) {
911 _this->_impl_.order_ = from._impl_.order_;
912 }
913 if (cached_has_bits & 0x00000008u) {
914 _this->_impl_.considered_ = from._impl_.considered_;
915 }
916 if (cached_has_bits & 0x00000010u) {
917 _this->_impl_.defer_shift_ = from._impl_.defer_shift_;
918 }
919 if (cached_has_bits & 0x00000020u) {
920 _this->_impl_.order_failed_ = from._impl_.order_failed_;
921 }
922 _this->_impl_._has_bits_[0] |= cached_has_bits;
923 }
924 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
925 }
926
CopyFrom(const MmCompactionDeferCompactionFtraceEvent & from)927 void MmCompactionDeferCompactionFtraceEvent::CopyFrom(const MmCompactionDeferCompactionFtraceEvent& from) {
928 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionDeferCompactionFtraceEvent)
929 if (&from == this) return;
930 Clear();
931 MergeFrom(from);
932 }
933
IsInitialized() const934 bool MmCompactionDeferCompactionFtraceEvent::IsInitialized() const {
935 return true;
936 }
937
InternalSwap(MmCompactionDeferCompactionFtraceEvent * other)938 void MmCompactionDeferCompactionFtraceEvent::InternalSwap(MmCompactionDeferCompactionFtraceEvent* other) {
939 using std::swap;
940 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
941 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
942 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
943 PROTOBUF_FIELD_OFFSET(MmCompactionDeferCompactionFtraceEvent, _impl_.order_failed_)
944 + sizeof(MmCompactionDeferCompactionFtraceEvent::_impl_.order_failed_) // NOLINT
945 - PROTOBUF_FIELD_OFFSET(MmCompactionDeferCompactionFtraceEvent, _impl_.nid_)>(
946 reinterpret_cast<char*>(&_impl_.nid_),
947 reinterpret_cast<char*>(&other->_impl_.nid_));
948 }
949
GetTypeName() const950 std::string MmCompactionDeferCompactionFtraceEvent::GetTypeName() const {
951 return "perfetto.protos.MmCompactionDeferCompactionFtraceEvent";
952 }
953
954
955 // ===================================================================
956
957 class MmCompactionDeferredFtraceEvent::_Internal {
958 public:
959 using HasBits = decltype(std::declval<MmCompactionDeferredFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)960 static void set_has_nid(HasBits* has_bits) {
961 (*has_bits)[0] |= 1u;
962 }
set_has_idx(HasBits * has_bits)963 static void set_has_idx(HasBits* has_bits) {
964 (*has_bits)[0] |= 2u;
965 }
set_has_order(HasBits * has_bits)966 static void set_has_order(HasBits* has_bits) {
967 (*has_bits)[0] |= 4u;
968 }
set_has_considered(HasBits * has_bits)969 static void set_has_considered(HasBits* has_bits) {
970 (*has_bits)[0] |= 8u;
971 }
set_has_defer_shift(HasBits * has_bits)972 static void set_has_defer_shift(HasBits* has_bits) {
973 (*has_bits)[0] |= 16u;
974 }
set_has_order_failed(HasBits * has_bits)975 static void set_has_order_failed(HasBits* has_bits) {
976 (*has_bits)[0] |= 32u;
977 }
978 };
979
MmCompactionDeferredFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)980 MmCompactionDeferredFtraceEvent::MmCompactionDeferredFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
981 bool is_message_owned)
982 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
983 SharedCtor(arena, is_message_owned);
984 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionDeferredFtraceEvent)
985 }
MmCompactionDeferredFtraceEvent(const MmCompactionDeferredFtraceEvent & from)986 MmCompactionDeferredFtraceEvent::MmCompactionDeferredFtraceEvent(const MmCompactionDeferredFtraceEvent& from)
987 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
988 MmCompactionDeferredFtraceEvent* const _this = this; (void)_this;
989 new (&_impl_) Impl_{
990 decltype(_impl_._has_bits_){from._impl_._has_bits_}
991 , /*decltype(_impl_._cached_size_)*/{}
992 , decltype(_impl_.nid_){}
993 , decltype(_impl_.idx_){}
994 , decltype(_impl_.order_){}
995 , decltype(_impl_.considered_){}
996 , decltype(_impl_.defer_shift_){}
997 , decltype(_impl_.order_failed_){}};
998
999 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1000 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
1001 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.order_failed_) -
1002 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.order_failed_));
1003 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionDeferredFtraceEvent)
1004 }
1005
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1006 inline void MmCompactionDeferredFtraceEvent::SharedCtor(
1007 ::_pb::Arena* arena, bool is_message_owned) {
1008 (void)arena;
1009 (void)is_message_owned;
1010 new (&_impl_) Impl_{
1011 decltype(_impl_._has_bits_){}
1012 , /*decltype(_impl_._cached_size_)*/{}
1013 , decltype(_impl_.nid_){0}
1014 , decltype(_impl_.idx_){0u}
1015 , decltype(_impl_.order_){0}
1016 , decltype(_impl_.considered_){0u}
1017 , decltype(_impl_.defer_shift_){0u}
1018 , decltype(_impl_.order_failed_){0}
1019 };
1020 }
1021
~MmCompactionDeferredFtraceEvent()1022 MmCompactionDeferredFtraceEvent::~MmCompactionDeferredFtraceEvent() {
1023 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionDeferredFtraceEvent)
1024 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1025 (void)arena;
1026 return;
1027 }
1028 SharedDtor();
1029 }
1030
SharedDtor()1031 inline void MmCompactionDeferredFtraceEvent::SharedDtor() {
1032 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1033 }
1034
SetCachedSize(int size) const1035 void MmCompactionDeferredFtraceEvent::SetCachedSize(int size) const {
1036 _impl_._cached_size_.Set(size);
1037 }
1038
Clear()1039 void MmCompactionDeferredFtraceEvent::Clear() {
1040 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionDeferredFtraceEvent)
1041 ::uint32_t cached_has_bits = 0;
1042 // Prevent compiler warnings about cached_has_bits being unused
1043 (void) cached_has_bits;
1044
1045 cached_has_bits = _impl_._has_bits_[0];
1046 if (cached_has_bits & 0x0000003fu) {
1047 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
1048 reinterpret_cast<char*>(&_impl_.order_failed_) -
1049 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.order_failed_));
1050 }
1051 _impl_._has_bits_.Clear();
1052 _internal_metadata_.Clear<std::string>();
1053 }
1054
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1055 const char* MmCompactionDeferredFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1056 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1057 _Internal::HasBits has_bits{};
1058 while (!ctx->Done(&ptr)) {
1059 ::uint32_t tag;
1060 ptr = ::_pbi::ReadTag(ptr, &tag);
1061 switch (tag >> 3) {
1062 // optional int32 nid = 1;
1063 case 1:
1064 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1065 _Internal::set_has_nid(&has_bits);
1066 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1067 CHK_(ptr);
1068 } else {
1069 goto handle_unusual;
1070 }
1071 continue;
1072 // optional uint32 idx = 2;
1073 case 2:
1074 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1075 _Internal::set_has_idx(&has_bits);
1076 _impl_.idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1077 CHK_(ptr);
1078 } else {
1079 goto handle_unusual;
1080 }
1081 continue;
1082 // optional int32 order = 3;
1083 case 3:
1084 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1085 _Internal::set_has_order(&has_bits);
1086 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1087 CHK_(ptr);
1088 } else {
1089 goto handle_unusual;
1090 }
1091 continue;
1092 // optional uint32 considered = 4;
1093 case 4:
1094 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1095 _Internal::set_has_considered(&has_bits);
1096 _impl_.considered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1097 CHK_(ptr);
1098 } else {
1099 goto handle_unusual;
1100 }
1101 continue;
1102 // optional uint32 defer_shift = 5;
1103 case 5:
1104 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1105 _Internal::set_has_defer_shift(&has_bits);
1106 _impl_.defer_shift_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1107 CHK_(ptr);
1108 } else {
1109 goto handle_unusual;
1110 }
1111 continue;
1112 // optional int32 order_failed = 6;
1113 case 6:
1114 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1115 _Internal::set_has_order_failed(&has_bits);
1116 _impl_.order_failed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1117 CHK_(ptr);
1118 } else {
1119 goto handle_unusual;
1120 }
1121 continue;
1122 default:
1123 goto handle_unusual;
1124 } // switch
1125 handle_unusual:
1126 if ((tag == 0) || ((tag & 7) == 4)) {
1127 CHK_(ptr);
1128 ctx->SetLastTag(tag);
1129 goto message_done;
1130 }
1131 ptr = UnknownFieldParse(
1132 tag,
1133 _internal_metadata_.mutable_unknown_fields<std::string>(),
1134 ptr, ctx);
1135 CHK_(ptr != nullptr);
1136 } // while
1137 message_done:
1138 _impl_._has_bits_.Or(has_bits);
1139 return ptr;
1140 failure:
1141 ptr = nullptr;
1142 goto message_done;
1143 #undef CHK_
1144 }
1145
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1146 ::uint8_t* MmCompactionDeferredFtraceEvent::_InternalSerialize(
1147 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1148 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionDeferredFtraceEvent)
1149 ::uint32_t cached_has_bits = 0;
1150 (void) cached_has_bits;
1151
1152 cached_has_bits = _impl_._has_bits_[0];
1153 // optional int32 nid = 1;
1154 if (cached_has_bits & 0x00000001u) {
1155 target = stream->EnsureSpace(target);
1156 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
1157 }
1158
1159 // optional uint32 idx = 2;
1160 if (cached_has_bits & 0x00000002u) {
1161 target = stream->EnsureSpace(target);
1162 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_idx(), target);
1163 }
1164
1165 // optional int32 order = 3;
1166 if (cached_has_bits & 0x00000004u) {
1167 target = stream->EnsureSpace(target);
1168 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_order(), target);
1169 }
1170
1171 // optional uint32 considered = 4;
1172 if (cached_has_bits & 0x00000008u) {
1173 target = stream->EnsureSpace(target);
1174 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_considered(), target);
1175 }
1176
1177 // optional uint32 defer_shift = 5;
1178 if (cached_has_bits & 0x00000010u) {
1179 target = stream->EnsureSpace(target);
1180 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_defer_shift(), target);
1181 }
1182
1183 // optional int32 order_failed = 6;
1184 if (cached_has_bits & 0x00000020u) {
1185 target = stream->EnsureSpace(target);
1186 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_order_failed(), target);
1187 }
1188
1189 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1190 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1191 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1192 }
1193 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionDeferredFtraceEvent)
1194 return target;
1195 }
1196
ByteSizeLong() const1197 size_t MmCompactionDeferredFtraceEvent::ByteSizeLong() const {
1198 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionDeferredFtraceEvent)
1199 size_t total_size = 0;
1200
1201 ::uint32_t cached_has_bits = 0;
1202 // Prevent compiler warnings about cached_has_bits being unused
1203 (void) cached_has_bits;
1204
1205 cached_has_bits = _impl_._has_bits_[0];
1206 if (cached_has_bits & 0x0000003fu) {
1207 // optional int32 nid = 1;
1208 if (cached_has_bits & 0x00000001u) {
1209 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
1210 }
1211
1212 // optional uint32 idx = 2;
1213 if (cached_has_bits & 0x00000002u) {
1214 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_idx());
1215 }
1216
1217 // optional int32 order = 3;
1218 if (cached_has_bits & 0x00000004u) {
1219 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
1220 }
1221
1222 // optional uint32 considered = 4;
1223 if (cached_has_bits & 0x00000008u) {
1224 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_considered());
1225 }
1226
1227 // optional uint32 defer_shift = 5;
1228 if (cached_has_bits & 0x00000010u) {
1229 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_defer_shift());
1230 }
1231
1232 // optional int32 order_failed = 6;
1233 if (cached_has_bits & 0x00000020u) {
1234 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order_failed());
1235 }
1236
1237 }
1238 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1239 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1240 }
1241 int cached_size = ::_pbi::ToCachedSize(total_size);
1242 SetCachedSize(cached_size);
1243 return total_size;
1244 }
1245
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1246 void MmCompactionDeferredFtraceEvent::CheckTypeAndMergeFrom(
1247 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1248 MergeFrom(*::_pbi::DownCast<const MmCompactionDeferredFtraceEvent*>(
1249 &from));
1250 }
1251
MergeFrom(const MmCompactionDeferredFtraceEvent & from)1252 void MmCompactionDeferredFtraceEvent::MergeFrom(const MmCompactionDeferredFtraceEvent& from) {
1253 MmCompactionDeferredFtraceEvent* const _this = this;
1254 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionDeferredFtraceEvent)
1255 GOOGLE_DCHECK_NE(&from, _this);
1256 ::uint32_t cached_has_bits = 0;
1257 (void) cached_has_bits;
1258
1259 cached_has_bits = from._impl_._has_bits_[0];
1260 if (cached_has_bits & 0x0000003fu) {
1261 if (cached_has_bits & 0x00000001u) {
1262 _this->_impl_.nid_ = from._impl_.nid_;
1263 }
1264 if (cached_has_bits & 0x00000002u) {
1265 _this->_impl_.idx_ = from._impl_.idx_;
1266 }
1267 if (cached_has_bits & 0x00000004u) {
1268 _this->_impl_.order_ = from._impl_.order_;
1269 }
1270 if (cached_has_bits & 0x00000008u) {
1271 _this->_impl_.considered_ = from._impl_.considered_;
1272 }
1273 if (cached_has_bits & 0x00000010u) {
1274 _this->_impl_.defer_shift_ = from._impl_.defer_shift_;
1275 }
1276 if (cached_has_bits & 0x00000020u) {
1277 _this->_impl_.order_failed_ = from._impl_.order_failed_;
1278 }
1279 _this->_impl_._has_bits_[0] |= cached_has_bits;
1280 }
1281 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1282 }
1283
CopyFrom(const MmCompactionDeferredFtraceEvent & from)1284 void MmCompactionDeferredFtraceEvent::CopyFrom(const MmCompactionDeferredFtraceEvent& from) {
1285 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionDeferredFtraceEvent)
1286 if (&from == this) return;
1287 Clear();
1288 MergeFrom(from);
1289 }
1290
IsInitialized() const1291 bool MmCompactionDeferredFtraceEvent::IsInitialized() const {
1292 return true;
1293 }
1294
InternalSwap(MmCompactionDeferredFtraceEvent * other)1295 void MmCompactionDeferredFtraceEvent::InternalSwap(MmCompactionDeferredFtraceEvent* other) {
1296 using std::swap;
1297 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1298 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1299 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1300 PROTOBUF_FIELD_OFFSET(MmCompactionDeferredFtraceEvent, _impl_.order_failed_)
1301 + sizeof(MmCompactionDeferredFtraceEvent::_impl_.order_failed_) // NOLINT
1302 - PROTOBUF_FIELD_OFFSET(MmCompactionDeferredFtraceEvent, _impl_.nid_)>(
1303 reinterpret_cast<char*>(&_impl_.nid_),
1304 reinterpret_cast<char*>(&other->_impl_.nid_));
1305 }
1306
GetTypeName() const1307 std::string MmCompactionDeferredFtraceEvent::GetTypeName() const {
1308 return "perfetto.protos.MmCompactionDeferredFtraceEvent";
1309 }
1310
1311
1312 // ===================================================================
1313
1314 class MmCompactionDeferResetFtraceEvent::_Internal {
1315 public:
1316 using HasBits = decltype(std::declval<MmCompactionDeferResetFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)1317 static void set_has_nid(HasBits* has_bits) {
1318 (*has_bits)[0] |= 1u;
1319 }
set_has_idx(HasBits * has_bits)1320 static void set_has_idx(HasBits* has_bits) {
1321 (*has_bits)[0] |= 2u;
1322 }
set_has_order(HasBits * has_bits)1323 static void set_has_order(HasBits* has_bits) {
1324 (*has_bits)[0] |= 4u;
1325 }
set_has_considered(HasBits * has_bits)1326 static void set_has_considered(HasBits* has_bits) {
1327 (*has_bits)[0] |= 8u;
1328 }
set_has_defer_shift(HasBits * has_bits)1329 static void set_has_defer_shift(HasBits* has_bits) {
1330 (*has_bits)[0] |= 16u;
1331 }
set_has_order_failed(HasBits * has_bits)1332 static void set_has_order_failed(HasBits* has_bits) {
1333 (*has_bits)[0] |= 32u;
1334 }
1335 };
1336
MmCompactionDeferResetFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1337 MmCompactionDeferResetFtraceEvent::MmCompactionDeferResetFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1338 bool is_message_owned)
1339 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1340 SharedCtor(arena, is_message_owned);
1341 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1342 }
MmCompactionDeferResetFtraceEvent(const MmCompactionDeferResetFtraceEvent & from)1343 MmCompactionDeferResetFtraceEvent::MmCompactionDeferResetFtraceEvent(const MmCompactionDeferResetFtraceEvent& from)
1344 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1345 MmCompactionDeferResetFtraceEvent* const _this = this; (void)_this;
1346 new (&_impl_) Impl_{
1347 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1348 , /*decltype(_impl_._cached_size_)*/{}
1349 , decltype(_impl_.nid_){}
1350 , decltype(_impl_.idx_){}
1351 , decltype(_impl_.order_){}
1352 , decltype(_impl_.considered_){}
1353 , decltype(_impl_.defer_shift_){}
1354 , decltype(_impl_.order_failed_){}};
1355
1356 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1357 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
1358 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.order_failed_) -
1359 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.order_failed_));
1360 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1361 }
1362
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1363 inline void MmCompactionDeferResetFtraceEvent::SharedCtor(
1364 ::_pb::Arena* arena, bool is_message_owned) {
1365 (void)arena;
1366 (void)is_message_owned;
1367 new (&_impl_) Impl_{
1368 decltype(_impl_._has_bits_){}
1369 , /*decltype(_impl_._cached_size_)*/{}
1370 , decltype(_impl_.nid_){0}
1371 , decltype(_impl_.idx_){0u}
1372 , decltype(_impl_.order_){0}
1373 , decltype(_impl_.considered_){0u}
1374 , decltype(_impl_.defer_shift_){0u}
1375 , decltype(_impl_.order_failed_){0}
1376 };
1377 }
1378
~MmCompactionDeferResetFtraceEvent()1379 MmCompactionDeferResetFtraceEvent::~MmCompactionDeferResetFtraceEvent() {
1380 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1381 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1382 (void)arena;
1383 return;
1384 }
1385 SharedDtor();
1386 }
1387
SharedDtor()1388 inline void MmCompactionDeferResetFtraceEvent::SharedDtor() {
1389 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1390 }
1391
SetCachedSize(int size) const1392 void MmCompactionDeferResetFtraceEvent::SetCachedSize(int size) const {
1393 _impl_._cached_size_.Set(size);
1394 }
1395
Clear()1396 void MmCompactionDeferResetFtraceEvent::Clear() {
1397 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1398 ::uint32_t cached_has_bits = 0;
1399 // Prevent compiler warnings about cached_has_bits being unused
1400 (void) cached_has_bits;
1401
1402 cached_has_bits = _impl_._has_bits_[0];
1403 if (cached_has_bits & 0x0000003fu) {
1404 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
1405 reinterpret_cast<char*>(&_impl_.order_failed_) -
1406 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.order_failed_));
1407 }
1408 _impl_._has_bits_.Clear();
1409 _internal_metadata_.Clear<std::string>();
1410 }
1411
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1412 const char* MmCompactionDeferResetFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1413 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1414 _Internal::HasBits has_bits{};
1415 while (!ctx->Done(&ptr)) {
1416 ::uint32_t tag;
1417 ptr = ::_pbi::ReadTag(ptr, &tag);
1418 switch (tag >> 3) {
1419 // optional int32 nid = 1;
1420 case 1:
1421 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1422 _Internal::set_has_nid(&has_bits);
1423 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1424 CHK_(ptr);
1425 } else {
1426 goto handle_unusual;
1427 }
1428 continue;
1429 // optional uint32 idx = 2;
1430 case 2:
1431 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1432 _Internal::set_has_idx(&has_bits);
1433 _impl_.idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1434 CHK_(ptr);
1435 } else {
1436 goto handle_unusual;
1437 }
1438 continue;
1439 // optional int32 order = 3;
1440 case 3:
1441 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1442 _Internal::set_has_order(&has_bits);
1443 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1444 CHK_(ptr);
1445 } else {
1446 goto handle_unusual;
1447 }
1448 continue;
1449 // optional uint32 considered = 4;
1450 case 4:
1451 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1452 _Internal::set_has_considered(&has_bits);
1453 _impl_.considered_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1454 CHK_(ptr);
1455 } else {
1456 goto handle_unusual;
1457 }
1458 continue;
1459 // optional uint32 defer_shift = 5;
1460 case 5:
1461 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1462 _Internal::set_has_defer_shift(&has_bits);
1463 _impl_.defer_shift_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1464 CHK_(ptr);
1465 } else {
1466 goto handle_unusual;
1467 }
1468 continue;
1469 // optional int32 order_failed = 6;
1470 case 6:
1471 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1472 _Internal::set_has_order_failed(&has_bits);
1473 _impl_.order_failed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1474 CHK_(ptr);
1475 } else {
1476 goto handle_unusual;
1477 }
1478 continue;
1479 default:
1480 goto handle_unusual;
1481 } // switch
1482 handle_unusual:
1483 if ((tag == 0) || ((tag & 7) == 4)) {
1484 CHK_(ptr);
1485 ctx->SetLastTag(tag);
1486 goto message_done;
1487 }
1488 ptr = UnknownFieldParse(
1489 tag,
1490 _internal_metadata_.mutable_unknown_fields<std::string>(),
1491 ptr, ctx);
1492 CHK_(ptr != nullptr);
1493 } // while
1494 message_done:
1495 _impl_._has_bits_.Or(has_bits);
1496 return ptr;
1497 failure:
1498 ptr = nullptr;
1499 goto message_done;
1500 #undef CHK_
1501 }
1502
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1503 ::uint8_t* MmCompactionDeferResetFtraceEvent::_InternalSerialize(
1504 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1505 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1506 ::uint32_t cached_has_bits = 0;
1507 (void) cached_has_bits;
1508
1509 cached_has_bits = _impl_._has_bits_[0];
1510 // optional int32 nid = 1;
1511 if (cached_has_bits & 0x00000001u) {
1512 target = stream->EnsureSpace(target);
1513 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
1514 }
1515
1516 // optional uint32 idx = 2;
1517 if (cached_has_bits & 0x00000002u) {
1518 target = stream->EnsureSpace(target);
1519 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_idx(), target);
1520 }
1521
1522 // optional int32 order = 3;
1523 if (cached_has_bits & 0x00000004u) {
1524 target = stream->EnsureSpace(target);
1525 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_order(), target);
1526 }
1527
1528 // optional uint32 considered = 4;
1529 if (cached_has_bits & 0x00000008u) {
1530 target = stream->EnsureSpace(target);
1531 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_considered(), target);
1532 }
1533
1534 // optional uint32 defer_shift = 5;
1535 if (cached_has_bits & 0x00000010u) {
1536 target = stream->EnsureSpace(target);
1537 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_defer_shift(), target);
1538 }
1539
1540 // optional int32 order_failed = 6;
1541 if (cached_has_bits & 0x00000020u) {
1542 target = stream->EnsureSpace(target);
1543 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_order_failed(), target);
1544 }
1545
1546 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1547 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1548 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1549 }
1550 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1551 return target;
1552 }
1553
ByteSizeLong() const1554 size_t MmCompactionDeferResetFtraceEvent::ByteSizeLong() const {
1555 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1556 size_t total_size = 0;
1557
1558 ::uint32_t cached_has_bits = 0;
1559 // Prevent compiler warnings about cached_has_bits being unused
1560 (void) cached_has_bits;
1561
1562 cached_has_bits = _impl_._has_bits_[0];
1563 if (cached_has_bits & 0x0000003fu) {
1564 // optional int32 nid = 1;
1565 if (cached_has_bits & 0x00000001u) {
1566 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
1567 }
1568
1569 // optional uint32 idx = 2;
1570 if (cached_has_bits & 0x00000002u) {
1571 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_idx());
1572 }
1573
1574 // optional int32 order = 3;
1575 if (cached_has_bits & 0x00000004u) {
1576 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
1577 }
1578
1579 // optional uint32 considered = 4;
1580 if (cached_has_bits & 0x00000008u) {
1581 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_considered());
1582 }
1583
1584 // optional uint32 defer_shift = 5;
1585 if (cached_has_bits & 0x00000010u) {
1586 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_defer_shift());
1587 }
1588
1589 // optional int32 order_failed = 6;
1590 if (cached_has_bits & 0x00000020u) {
1591 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order_failed());
1592 }
1593
1594 }
1595 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1596 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1597 }
1598 int cached_size = ::_pbi::ToCachedSize(total_size);
1599 SetCachedSize(cached_size);
1600 return total_size;
1601 }
1602
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1603 void MmCompactionDeferResetFtraceEvent::CheckTypeAndMergeFrom(
1604 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1605 MergeFrom(*::_pbi::DownCast<const MmCompactionDeferResetFtraceEvent*>(
1606 &from));
1607 }
1608
MergeFrom(const MmCompactionDeferResetFtraceEvent & from)1609 void MmCompactionDeferResetFtraceEvent::MergeFrom(const MmCompactionDeferResetFtraceEvent& from) {
1610 MmCompactionDeferResetFtraceEvent* const _this = this;
1611 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1612 GOOGLE_DCHECK_NE(&from, _this);
1613 ::uint32_t cached_has_bits = 0;
1614 (void) cached_has_bits;
1615
1616 cached_has_bits = from._impl_._has_bits_[0];
1617 if (cached_has_bits & 0x0000003fu) {
1618 if (cached_has_bits & 0x00000001u) {
1619 _this->_impl_.nid_ = from._impl_.nid_;
1620 }
1621 if (cached_has_bits & 0x00000002u) {
1622 _this->_impl_.idx_ = from._impl_.idx_;
1623 }
1624 if (cached_has_bits & 0x00000004u) {
1625 _this->_impl_.order_ = from._impl_.order_;
1626 }
1627 if (cached_has_bits & 0x00000008u) {
1628 _this->_impl_.considered_ = from._impl_.considered_;
1629 }
1630 if (cached_has_bits & 0x00000010u) {
1631 _this->_impl_.defer_shift_ = from._impl_.defer_shift_;
1632 }
1633 if (cached_has_bits & 0x00000020u) {
1634 _this->_impl_.order_failed_ = from._impl_.order_failed_;
1635 }
1636 _this->_impl_._has_bits_[0] |= cached_has_bits;
1637 }
1638 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1639 }
1640
CopyFrom(const MmCompactionDeferResetFtraceEvent & from)1641 void MmCompactionDeferResetFtraceEvent::CopyFrom(const MmCompactionDeferResetFtraceEvent& from) {
1642 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionDeferResetFtraceEvent)
1643 if (&from == this) return;
1644 Clear();
1645 MergeFrom(from);
1646 }
1647
IsInitialized() const1648 bool MmCompactionDeferResetFtraceEvent::IsInitialized() const {
1649 return true;
1650 }
1651
InternalSwap(MmCompactionDeferResetFtraceEvent * other)1652 void MmCompactionDeferResetFtraceEvent::InternalSwap(MmCompactionDeferResetFtraceEvent* other) {
1653 using std::swap;
1654 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1655 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1656 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1657 PROTOBUF_FIELD_OFFSET(MmCompactionDeferResetFtraceEvent, _impl_.order_failed_)
1658 + sizeof(MmCompactionDeferResetFtraceEvent::_impl_.order_failed_) // NOLINT
1659 - PROTOBUF_FIELD_OFFSET(MmCompactionDeferResetFtraceEvent, _impl_.nid_)>(
1660 reinterpret_cast<char*>(&_impl_.nid_),
1661 reinterpret_cast<char*>(&other->_impl_.nid_));
1662 }
1663
GetTypeName() const1664 std::string MmCompactionDeferResetFtraceEvent::GetTypeName() const {
1665 return "perfetto.protos.MmCompactionDeferResetFtraceEvent";
1666 }
1667
1668
1669 // ===================================================================
1670
1671 class MmCompactionEndFtraceEvent::_Internal {
1672 public:
1673 using HasBits = decltype(std::declval<MmCompactionEndFtraceEvent>()._impl_._has_bits_);
set_has_zone_start(HasBits * has_bits)1674 static void set_has_zone_start(HasBits* has_bits) {
1675 (*has_bits)[0] |= 1u;
1676 }
set_has_migrate_pfn(HasBits * has_bits)1677 static void set_has_migrate_pfn(HasBits* has_bits) {
1678 (*has_bits)[0] |= 2u;
1679 }
set_has_free_pfn(HasBits * has_bits)1680 static void set_has_free_pfn(HasBits* has_bits) {
1681 (*has_bits)[0] |= 4u;
1682 }
set_has_zone_end(HasBits * has_bits)1683 static void set_has_zone_end(HasBits* has_bits) {
1684 (*has_bits)[0] |= 8u;
1685 }
set_has_sync(HasBits * has_bits)1686 static void set_has_sync(HasBits* has_bits) {
1687 (*has_bits)[0] |= 16u;
1688 }
set_has_status(HasBits * has_bits)1689 static void set_has_status(HasBits* has_bits) {
1690 (*has_bits)[0] |= 32u;
1691 }
1692 };
1693
MmCompactionEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1694 MmCompactionEndFtraceEvent::MmCompactionEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1695 bool is_message_owned)
1696 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1697 SharedCtor(arena, is_message_owned);
1698 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionEndFtraceEvent)
1699 }
MmCompactionEndFtraceEvent(const MmCompactionEndFtraceEvent & from)1700 MmCompactionEndFtraceEvent::MmCompactionEndFtraceEvent(const MmCompactionEndFtraceEvent& from)
1701 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1702 MmCompactionEndFtraceEvent* const _this = this; (void)_this;
1703 new (&_impl_) Impl_{
1704 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1705 , /*decltype(_impl_._cached_size_)*/{}
1706 , decltype(_impl_.zone_start_){}
1707 , decltype(_impl_.migrate_pfn_){}
1708 , decltype(_impl_.free_pfn_){}
1709 , decltype(_impl_.zone_end_){}
1710 , decltype(_impl_.sync_){}
1711 , decltype(_impl_.status_){}};
1712
1713 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1714 ::memcpy(&_impl_.zone_start_, &from._impl_.zone_start_,
1715 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.status_) -
1716 reinterpret_cast<char*>(&_impl_.zone_start_)) + sizeof(_impl_.status_));
1717 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionEndFtraceEvent)
1718 }
1719
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1720 inline void MmCompactionEndFtraceEvent::SharedCtor(
1721 ::_pb::Arena* arena, bool is_message_owned) {
1722 (void)arena;
1723 (void)is_message_owned;
1724 new (&_impl_) Impl_{
1725 decltype(_impl_._has_bits_){}
1726 , /*decltype(_impl_._cached_size_)*/{}
1727 , decltype(_impl_.zone_start_){::uint64_t{0u}}
1728 , decltype(_impl_.migrate_pfn_){::uint64_t{0u}}
1729 , decltype(_impl_.free_pfn_){::uint64_t{0u}}
1730 , decltype(_impl_.zone_end_){::uint64_t{0u}}
1731 , decltype(_impl_.sync_){0u}
1732 , decltype(_impl_.status_){0}
1733 };
1734 }
1735
~MmCompactionEndFtraceEvent()1736 MmCompactionEndFtraceEvent::~MmCompactionEndFtraceEvent() {
1737 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionEndFtraceEvent)
1738 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1739 (void)arena;
1740 return;
1741 }
1742 SharedDtor();
1743 }
1744
SharedDtor()1745 inline void MmCompactionEndFtraceEvent::SharedDtor() {
1746 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1747 }
1748
SetCachedSize(int size) const1749 void MmCompactionEndFtraceEvent::SetCachedSize(int size) const {
1750 _impl_._cached_size_.Set(size);
1751 }
1752
Clear()1753 void MmCompactionEndFtraceEvent::Clear() {
1754 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionEndFtraceEvent)
1755 ::uint32_t cached_has_bits = 0;
1756 // Prevent compiler warnings about cached_has_bits being unused
1757 (void) cached_has_bits;
1758
1759 cached_has_bits = _impl_._has_bits_[0];
1760 if (cached_has_bits & 0x0000003fu) {
1761 ::memset(&_impl_.zone_start_, 0, static_cast<size_t>(
1762 reinterpret_cast<char*>(&_impl_.status_) -
1763 reinterpret_cast<char*>(&_impl_.zone_start_)) + sizeof(_impl_.status_));
1764 }
1765 _impl_._has_bits_.Clear();
1766 _internal_metadata_.Clear<std::string>();
1767 }
1768
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1769 const char* MmCompactionEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1770 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1771 _Internal::HasBits has_bits{};
1772 while (!ctx->Done(&ptr)) {
1773 ::uint32_t tag;
1774 ptr = ::_pbi::ReadTag(ptr, &tag);
1775 switch (tag >> 3) {
1776 // optional uint64 zone_start = 1;
1777 case 1:
1778 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1779 _Internal::set_has_zone_start(&has_bits);
1780 _impl_.zone_start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1781 CHK_(ptr);
1782 } else {
1783 goto handle_unusual;
1784 }
1785 continue;
1786 // optional uint64 migrate_pfn = 2;
1787 case 2:
1788 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1789 _Internal::set_has_migrate_pfn(&has_bits);
1790 _impl_.migrate_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1791 CHK_(ptr);
1792 } else {
1793 goto handle_unusual;
1794 }
1795 continue;
1796 // optional uint64 free_pfn = 3;
1797 case 3:
1798 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1799 _Internal::set_has_free_pfn(&has_bits);
1800 _impl_.free_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1801 CHK_(ptr);
1802 } else {
1803 goto handle_unusual;
1804 }
1805 continue;
1806 // optional uint64 zone_end = 4;
1807 case 4:
1808 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1809 _Internal::set_has_zone_end(&has_bits);
1810 _impl_.zone_end_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1811 CHK_(ptr);
1812 } else {
1813 goto handle_unusual;
1814 }
1815 continue;
1816 // optional uint32 sync = 5;
1817 case 5:
1818 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1819 _Internal::set_has_sync(&has_bits);
1820 _impl_.sync_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1821 CHK_(ptr);
1822 } else {
1823 goto handle_unusual;
1824 }
1825 continue;
1826 // optional int32 status = 6;
1827 case 6:
1828 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1829 _Internal::set_has_status(&has_bits);
1830 _impl_.status_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1831 CHK_(ptr);
1832 } else {
1833 goto handle_unusual;
1834 }
1835 continue;
1836 default:
1837 goto handle_unusual;
1838 } // switch
1839 handle_unusual:
1840 if ((tag == 0) || ((tag & 7) == 4)) {
1841 CHK_(ptr);
1842 ctx->SetLastTag(tag);
1843 goto message_done;
1844 }
1845 ptr = UnknownFieldParse(
1846 tag,
1847 _internal_metadata_.mutable_unknown_fields<std::string>(),
1848 ptr, ctx);
1849 CHK_(ptr != nullptr);
1850 } // while
1851 message_done:
1852 _impl_._has_bits_.Or(has_bits);
1853 return ptr;
1854 failure:
1855 ptr = nullptr;
1856 goto message_done;
1857 #undef CHK_
1858 }
1859
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1860 ::uint8_t* MmCompactionEndFtraceEvent::_InternalSerialize(
1861 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1862 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionEndFtraceEvent)
1863 ::uint32_t cached_has_bits = 0;
1864 (void) cached_has_bits;
1865
1866 cached_has_bits = _impl_._has_bits_[0];
1867 // optional uint64 zone_start = 1;
1868 if (cached_has_bits & 0x00000001u) {
1869 target = stream->EnsureSpace(target);
1870 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_zone_start(), target);
1871 }
1872
1873 // optional uint64 migrate_pfn = 2;
1874 if (cached_has_bits & 0x00000002u) {
1875 target = stream->EnsureSpace(target);
1876 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_migrate_pfn(), target);
1877 }
1878
1879 // optional uint64 free_pfn = 3;
1880 if (cached_has_bits & 0x00000004u) {
1881 target = stream->EnsureSpace(target);
1882 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_free_pfn(), target);
1883 }
1884
1885 // optional uint64 zone_end = 4;
1886 if (cached_has_bits & 0x00000008u) {
1887 target = stream->EnsureSpace(target);
1888 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_zone_end(), target);
1889 }
1890
1891 // optional uint32 sync = 5;
1892 if (cached_has_bits & 0x00000010u) {
1893 target = stream->EnsureSpace(target);
1894 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_sync(), target);
1895 }
1896
1897 // optional int32 status = 6;
1898 if (cached_has_bits & 0x00000020u) {
1899 target = stream->EnsureSpace(target);
1900 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_status(), target);
1901 }
1902
1903 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1904 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1905 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1906 }
1907 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionEndFtraceEvent)
1908 return target;
1909 }
1910
ByteSizeLong() const1911 size_t MmCompactionEndFtraceEvent::ByteSizeLong() const {
1912 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionEndFtraceEvent)
1913 size_t total_size = 0;
1914
1915 ::uint32_t cached_has_bits = 0;
1916 // Prevent compiler warnings about cached_has_bits being unused
1917 (void) cached_has_bits;
1918
1919 cached_has_bits = _impl_._has_bits_[0];
1920 if (cached_has_bits & 0x0000003fu) {
1921 // optional uint64 zone_start = 1;
1922 if (cached_has_bits & 0x00000001u) {
1923 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_zone_start());
1924 }
1925
1926 // optional uint64 migrate_pfn = 2;
1927 if (cached_has_bits & 0x00000002u) {
1928 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_migrate_pfn());
1929 }
1930
1931 // optional uint64 free_pfn = 3;
1932 if (cached_has_bits & 0x00000004u) {
1933 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_free_pfn());
1934 }
1935
1936 // optional uint64 zone_end = 4;
1937 if (cached_has_bits & 0x00000008u) {
1938 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_zone_end());
1939 }
1940
1941 // optional uint32 sync = 5;
1942 if (cached_has_bits & 0x00000010u) {
1943 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_sync());
1944 }
1945
1946 // optional int32 status = 6;
1947 if (cached_has_bits & 0x00000020u) {
1948 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_status());
1949 }
1950
1951 }
1952 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1953 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1954 }
1955 int cached_size = ::_pbi::ToCachedSize(total_size);
1956 SetCachedSize(cached_size);
1957 return total_size;
1958 }
1959
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1960 void MmCompactionEndFtraceEvent::CheckTypeAndMergeFrom(
1961 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1962 MergeFrom(*::_pbi::DownCast<const MmCompactionEndFtraceEvent*>(
1963 &from));
1964 }
1965
MergeFrom(const MmCompactionEndFtraceEvent & from)1966 void MmCompactionEndFtraceEvent::MergeFrom(const MmCompactionEndFtraceEvent& from) {
1967 MmCompactionEndFtraceEvent* const _this = this;
1968 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionEndFtraceEvent)
1969 GOOGLE_DCHECK_NE(&from, _this);
1970 ::uint32_t cached_has_bits = 0;
1971 (void) cached_has_bits;
1972
1973 cached_has_bits = from._impl_._has_bits_[0];
1974 if (cached_has_bits & 0x0000003fu) {
1975 if (cached_has_bits & 0x00000001u) {
1976 _this->_impl_.zone_start_ = from._impl_.zone_start_;
1977 }
1978 if (cached_has_bits & 0x00000002u) {
1979 _this->_impl_.migrate_pfn_ = from._impl_.migrate_pfn_;
1980 }
1981 if (cached_has_bits & 0x00000004u) {
1982 _this->_impl_.free_pfn_ = from._impl_.free_pfn_;
1983 }
1984 if (cached_has_bits & 0x00000008u) {
1985 _this->_impl_.zone_end_ = from._impl_.zone_end_;
1986 }
1987 if (cached_has_bits & 0x00000010u) {
1988 _this->_impl_.sync_ = from._impl_.sync_;
1989 }
1990 if (cached_has_bits & 0x00000020u) {
1991 _this->_impl_.status_ = from._impl_.status_;
1992 }
1993 _this->_impl_._has_bits_[0] |= cached_has_bits;
1994 }
1995 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1996 }
1997
CopyFrom(const MmCompactionEndFtraceEvent & from)1998 void MmCompactionEndFtraceEvent::CopyFrom(const MmCompactionEndFtraceEvent& from) {
1999 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionEndFtraceEvent)
2000 if (&from == this) return;
2001 Clear();
2002 MergeFrom(from);
2003 }
2004
IsInitialized() const2005 bool MmCompactionEndFtraceEvent::IsInitialized() const {
2006 return true;
2007 }
2008
InternalSwap(MmCompactionEndFtraceEvent * other)2009 void MmCompactionEndFtraceEvent::InternalSwap(MmCompactionEndFtraceEvent* other) {
2010 using std::swap;
2011 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2012 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2013 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2014 PROTOBUF_FIELD_OFFSET(MmCompactionEndFtraceEvent, _impl_.status_)
2015 + sizeof(MmCompactionEndFtraceEvent::_impl_.status_) // NOLINT
2016 - PROTOBUF_FIELD_OFFSET(MmCompactionEndFtraceEvent, _impl_.zone_start_)>(
2017 reinterpret_cast<char*>(&_impl_.zone_start_),
2018 reinterpret_cast<char*>(&other->_impl_.zone_start_));
2019 }
2020
GetTypeName() const2021 std::string MmCompactionEndFtraceEvent::GetTypeName() const {
2022 return "perfetto.protos.MmCompactionEndFtraceEvent";
2023 }
2024
2025
2026 // ===================================================================
2027
2028 class MmCompactionFinishedFtraceEvent::_Internal {
2029 public:
2030 using HasBits = decltype(std::declval<MmCompactionFinishedFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)2031 static void set_has_nid(HasBits* has_bits) {
2032 (*has_bits)[0] |= 1u;
2033 }
set_has_idx(HasBits * has_bits)2034 static void set_has_idx(HasBits* has_bits) {
2035 (*has_bits)[0] |= 2u;
2036 }
set_has_order(HasBits * has_bits)2037 static void set_has_order(HasBits* has_bits) {
2038 (*has_bits)[0] |= 4u;
2039 }
set_has_ret(HasBits * has_bits)2040 static void set_has_ret(HasBits* has_bits) {
2041 (*has_bits)[0] |= 8u;
2042 }
2043 };
2044
MmCompactionFinishedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2045 MmCompactionFinishedFtraceEvent::MmCompactionFinishedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2046 bool is_message_owned)
2047 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2048 SharedCtor(arena, is_message_owned);
2049 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionFinishedFtraceEvent)
2050 }
MmCompactionFinishedFtraceEvent(const MmCompactionFinishedFtraceEvent & from)2051 MmCompactionFinishedFtraceEvent::MmCompactionFinishedFtraceEvent(const MmCompactionFinishedFtraceEvent& from)
2052 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2053 MmCompactionFinishedFtraceEvent* const _this = this; (void)_this;
2054 new (&_impl_) Impl_{
2055 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2056 , /*decltype(_impl_._cached_size_)*/{}
2057 , decltype(_impl_.nid_){}
2058 , decltype(_impl_.idx_){}
2059 , decltype(_impl_.order_){}
2060 , decltype(_impl_.ret_){}};
2061
2062 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2063 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
2064 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ret_) -
2065 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.ret_));
2066 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionFinishedFtraceEvent)
2067 }
2068
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2069 inline void MmCompactionFinishedFtraceEvent::SharedCtor(
2070 ::_pb::Arena* arena, bool is_message_owned) {
2071 (void)arena;
2072 (void)is_message_owned;
2073 new (&_impl_) Impl_{
2074 decltype(_impl_._has_bits_){}
2075 , /*decltype(_impl_._cached_size_)*/{}
2076 , decltype(_impl_.nid_){0}
2077 , decltype(_impl_.idx_){0u}
2078 , decltype(_impl_.order_){0}
2079 , decltype(_impl_.ret_){0}
2080 };
2081 }
2082
~MmCompactionFinishedFtraceEvent()2083 MmCompactionFinishedFtraceEvent::~MmCompactionFinishedFtraceEvent() {
2084 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionFinishedFtraceEvent)
2085 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2086 (void)arena;
2087 return;
2088 }
2089 SharedDtor();
2090 }
2091
SharedDtor()2092 inline void MmCompactionFinishedFtraceEvent::SharedDtor() {
2093 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2094 }
2095
SetCachedSize(int size) const2096 void MmCompactionFinishedFtraceEvent::SetCachedSize(int size) const {
2097 _impl_._cached_size_.Set(size);
2098 }
2099
Clear()2100 void MmCompactionFinishedFtraceEvent::Clear() {
2101 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionFinishedFtraceEvent)
2102 ::uint32_t cached_has_bits = 0;
2103 // Prevent compiler warnings about cached_has_bits being unused
2104 (void) cached_has_bits;
2105
2106 cached_has_bits = _impl_._has_bits_[0];
2107 if (cached_has_bits & 0x0000000fu) {
2108 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
2109 reinterpret_cast<char*>(&_impl_.ret_) -
2110 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.ret_));
2111 }
2112 _impl_._has_bits_.Clear();
2113 _internal_metadata_.Clear<std::string>();
2114 }
2115
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2116 const char* MmCompactionFinishedFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2117 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2118 _Internal::HasBits has_bits{};
2119 while (!ctx->Done(&ptr)) {
2120 ::uint32_t tag;
2121 ptr = ::_pbi::ReadTag(ptr, &tag);
2122 switch (tag >> 3) {
2123 // optional int32 nid = 1;
2124 case 1:
2125 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2126 _Internal::set_has_nid(&has_bits);
2127 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2128 CHK_(ptr);
2129 } else {
2130 goto handle_unusual;
2131 }
2132 continue;
2133 // optional uint32 idx = 2;
2134 case 2:
2135 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2136 _Internal::set_has_idx(&has_bits);
2137 _impl_.idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2138 CHK_(ptr);
2139 } else {
2140 goto handle_unusual;
2141 }
2142 continue;
2143 // optional int32 order = 3;
2144 case 3:
2145 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2146 _Internal::set_has_order(&has_bits);
2147 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2148 CHK_(ptr);
2149 } else {
2150 goto handle_unusual;
2151 }
2152 continue;
2153 // optional int32 ret = 4;
2154 case 4:
2155 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2156 _Internal::set_has_ret(&has_bits);
2157 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2158 CHK_(ptr);
2159 } else {
2160 goto handle_unusual;
2161 }
2162 continue;
2163 default:
2164 goto handle_unusual;
2165 } // switch
2166 handle_unusual:
2167 if ((tag == 0) || ((tag & 7) == 4)) {
2168 CHK_(ptr);
2169 ctx->SetLastTag(tag);
2170 goto message_done;
2171 }
2172 ptr = UnknownFieldParse(
2173 tag,
2174 _internal_metadata_.mutable_unknown_fields<std::string>(),
2175 ptr, ctx);
2176 CHK_(ptr != nullptr);
2177 } // while
2178 message_done:
2179 _impl_._has_bits_.Or(has_bits);
2180 return ptr;
2181 failure:
2182 ptr = nullptr;
2183 goto message_done;
2184 #undef CHK_
2185 }
2186
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2187 ::uint8_t* MmCompactionFinishedFtraceEvent::_InternalSerialize(
2188 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2189 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionFinishedFtraceEvent)
2190 ::uint32_t cached_has_bits = 0;
2191 (void) cached_has_bits;
2192
2193 cached_has_bits = _impl_._has_bits_[0];
2194 // optional int32 nid = 1;
2195 if (cached_has_bits & 0x00000001u) {
2196 target = stream->EnsureSpace(target);
2197 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
2198 }
2199
2200 // optional uint32 idx = 2;
2201 if (cached_has_bits & 0x00000002u) {
2202 target = stream->EnsureSpace(target);
2203 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_idx(), target);
2204 }
2205
2206 // optional int32 order = 3;
2207 if (cached_has_bits & 0x00000004u) {
2208 target = stream->EnsureSpace(target);
2209 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_order(), target);
2210 }
2211
2212 // optional int32 ret = 4;
2213 if (cached_has_bits & 0x00000008u) {
2214 target = stream->EnsureSpace(target);
2215 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_ret(), target);
2216 }
2217
2218 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2219 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2220 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2221 }
2222 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionFinishedFtraceEvent)
2223 return target;
2224 }
2225
ByteSizeLong() const2226 size_t MmCompactionFinishedFtraceEvent::ByteSizeLong() const {
2227 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionFinishedFtraceEvent)
2228 size_t total_size = 0;
2229
2230 ::uint32_t cached_has_bits = 0;
2231 // Prevent compiler warnings about cached_has_bits being unused
2232 (void) cached_has_bits;
2233
2234 cached_has_bits = _impl_._has_bits_[0];
2235 if (cached_has_bits & 0x0000000fu) {
2236 // optional int32 nid = 1;
2237 if (cached_has_bits & 0x00000001u) {
2238 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
2239 }
2240
2241 // optional uint32 idx = 2;
2242 if (cached_has_bits & 0x00000002u) {
2243 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_idx());
2244 }
2245
2246 // optional int32 order = 3;
2247 if (cached_has_bits & 0x00000004u) {
2248 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
2249 }
2250
2251 // optional int32 ret = 4;
2252 if (cached_has_bits & 0x00000008u) {
2253 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
2254 }
2255
2256 }
2257 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2258 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2259 }
2260 int cached_size = ::_pbi::ToCachedSize(total_size);
2261 SetCachedSize(cached_size);
2262 return total_size;
2263 }
2264
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2265 void MmCompactionFinishedFtraceEvent::CheckTypeAndMergeFrom(
2266 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2267 MergeFrom(*::_pbi::DownCast<const MmCompactionFinishedFtraceEvent*>(
2268 &from));
2269 }
2270
MergeFrom(const MmCompactionFinishedFtraceEvent & from)2271 void MmCompactionFinishedFtraceEvent::MergeFrom(const MmCompactionFinishedFtraceEvent& from) {
2272 MmCompactionFinishedFtraceEvent* const _this = this;
2273 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionFinishedFtraceEvent)
2274 GOOGLE_DCHECK_NE(&from, _this);
2275 ::uint32_t cached_has_bits = 0;
2276 (void) cached_has_bits;
2277
2278 cached_has_bits = from._impl_._has_bits_[0];
2279 if (cached_has_bits & 0x0000000fu) {
2280 if (cached_has_bits & 0x00000001u) {
2281 _this->_impl_.nid_ = from._impl_.nid_;
2282 }
2283 if (cached_has_bits & 0x00000002u) {
2284 _this->_impl_.idx_ = from._impl_.idx_;
2285 }
2286 if (cached_has_bits & 0x00000004u) {
2287 _this->_impl_.order_ = from._impl_.order_;
2288 }
2289 if (cached_has_bits & 0x00000008u) {
2290 _this->_impl_.ret_ = from._impl_.ret_;
2291 }
2292 _this->_impl_._has_bits_[0] |= cached_has_bits;
2293 }
2294 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2295 }
2296
CopyFrom(const MmCompactionFinishedFtraceEvent & from)2297 void MmCompactionFinishedFtraceEvent::CopyFrom(const MmCompactionFinishedFtraceEvent& from) {
2298 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionFinishedFtraceEvent)
2299 if (&from == this) return;
2300 Clear();
2301 MergeFrom(from);
2302 }
2303
IsInitialized() const2304 bool MmCompactionFinishedFtraceEvent::IsInitialized() const {
2305 return true;
2306 }
2307
InternalSwap(MmCompactionFinishedFtraceEvent * other)2308 void MmCompactionFinishedFtraceEvent::InternalSwap(MmCompactionFinishedFtraceEvent* other) {
2309 using std::swap;
2310 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2311 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2312 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2313 PROTOBUF_FIELD_OFFSET(MmCompactionFinishedFtraceEvent, _impl_.ret_)
2314 + sizeof(MmCompactionFinishedFtraceEvent::_impl_.ret_) // NOLINT
2315 - PROTOBUF_FIELD_OFFSET(MmCompactionFinishedFtraceEvent, _impl_.nid_)>(
2316 reinterpret_cast<char*>(&_impl_.nid_),
2317 reinterpret_cast<char*>(&other->_impl_.nid_));
2318 }
2319
GetTypeName() const2320 std::string MmCompactionFinishedFtraceEvent::GetTypeName() const {
2321 return "perfetto.protos.MmCompactionFinishedFtraceEvent";
2322 }
2323
2324
2325 // ===================================================================
2326
2327 class MmCompactionIsolateFreepagesFtraceEvent::_Internal {
2328 public:
2329 using HasBits = decltype(std::declval<MmCompactionIsolateFreepagesFtraceEvent>()._impl_._has_bits_);
set_has_start_pfn(HasBits * has_bits)2330 static void set_has_start_pfn(HasBits* has_bits) {
2331 (*has_bits)[0] |= 1u;
2332 }
set_has_end_pfn(HasBits * has_bits)2333 static void set_has_end_pfn(HasBits* has_bits) {
2334 (*has_bits)[0] |= 2u;
2335 }
set_has_nr_scanned(HasBits * has_bits)2336 static void set_has_nr_scanned(HasBits* has_bits) {
2337 (*has_bits)[0] |= 4u;
2338 }
set_has_nr_taken(HasBits * has_bits)2339 static void set_has_nr_taken(HasBits* has_bits) {
2340 (*has_bits)[0] |= 8u;
2341 }
2342 };
2343
MmCompactionIsolateFreepagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2344 MmCompactionIsolateFreepagesFtraceEvent::MmCompactionIsolateFreepagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2345 bool is_message_owned)
2346 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2347 SharedCtor(arena, is_message_owned);
2348 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2349 }
MmCompactionIsolateFreepagesFtraceEvent(const MmCompactionIsolateFreepagesFtraceEvent & from)2350 MmCompactionIsolateFreepagesFtraceEvent::MmCompactionIsolateFreepagesFtraceEvent(const MmCompactionIsolateFreepagesFtraceEvent& from)
2351 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2352 MmCompactionIsolateFreepagesFtraceEvent* const _this = this; (void)_this;
2353 new (&_impl_) Impl_{
2354 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2355 , /*decltype(_impl_._cached_size_)*/{}
2356 , decltype(_impl_.start_pfn_){}
2357 , decltype(_impl_.end_pfn_){}
2358 , decltype(_impl_.nr_scanned_){}
2359 , decltype(_impl_.nr_taken_){}};
2360
2361 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2362 ::memcpy(&_impl_.start_pfn_, &from._impl_.start_pfn_,
2363 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_taken_) -
2364 reinterpret_cast<char*>(&_impl_.start_pfn_)) + sizeof(_impl_.nr_taken_));
2365 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2366 }
2367
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2368 inline void MmCompactionIsolateFreepagesFtraceEvent::SharedCtor(
2369 ::_pb::Arena* arena, bool is_message_owned) {
2370 (void)arena;
2371 (void)is_message_owned;
2372 new (&_impl_) Impl_{
2373 decltype(_impl_._has_bits_){}
2374 , /*decltype(_impl_._cached_size_)*/{}
2375 , decltype(_impl_.start_pfn_){::uint64_t{0u}}
2376 , decltype(_impl_.end_pfn_){::uint64_t{0u}}
2377 , decltype(_impl_.nr_scanned_){::uint64_t{0u}}
2378 , decltype(_impl_.nr_taken_){::uint64_t{0u}}
2379 };
2380 }
2381
~MmCompactionIsolateFreepagesFtraceEvent()2382 MmCompactionIsolateFreepagesFtraceEvent::~MmCompactionIsolateFreepagesFtraceEvent() {
2383 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2384 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2385 (void)arena;
2386 return;
2387 }
2388 SharedDtor();
2389 }
2390
SharedDtor()2391 inline void MmCompactionIsolateFreepagesFtraceEvent::SharedDtor() {
2392 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2393 }
2394
SetCachedSize(int size) const2395 void MmCompactionIsolateFreepagesFtraceEvent::SetCachedSize(int size) const {
2396 _impl_._cached_size_.Set(size);
2397 }
2398
Clear()2399 void MmCompactionIsolateFreepagesFtraceEvent::Clear() {
2400 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2401 ::uint32_t cached_has_bits = 0;
2402 // Prevent compiler warnings about cached_has_bits being unused
2403 (void) cached_has_bits;
2404
2405 cached_has_bits = _impl_._has_bits_[0];
2406 if (cached_has_bits & 0x0000000fu) {
2407 ::memset(&_impl_.start_pfn_, 0, static_cast<size_t>(
2408 reinterpret_cast<char*>(&_impl_.nr_taken_) -
2409 reinterpret_cast<char*>(&_impl_.start_pfn_)) + sizeof(_impl_.nr_taken_));
2410 }
2411 _impl_._has_bits_.Clear();
2412 _internal_metadata_.Clear<std::string>();
2413 }
2414
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2415 const char* MmCompactionIsolateFreepagesFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2416 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2417 _Internal::HasBits has_bits{};
2418 while (!ctx->Done(&ptr)) {
2419 ::uint32_t tag;
2420 ptr = ::_pbi::ReadTag(ptr, &tag);
2421 switch (tag >> 3) {
2422 // optional uint64 start_pfn = 1;
2423 case 1:
2424 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2425 _Internal::set_has_start_pfn(&has_bits);
2426 _impl_.start_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2427 CHK_(ptr);
2428 } else {
2429 goto handle_unusual;
2430 }
2431 continue;
2432 // optional uint64 end_pfn = 2;
2433 case 2:
2434 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2435 _Internal::set_has_end_pfn(&has_bits);
2436 _impl_.end_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2437 CHK_(ptr);
2438 } else {
2439 goto handle_unusual;
2440 }
2441 continue;
2442 // optional uint64 nr_scanned = 3;
2443 case 3:
2444 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2445 _Internal::set_has_nr_scanned(&has_bits);
2446 _impl_.nr_scanned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2447 CHK_(ptr);
2448 } else {
2449 goto handle_unusual;
2450 }
2451 continue;
2452 // optional uint64 nr_taken = 4;
2453 case 4:
2454 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2455 _Internal::set_has_nr_taken(&has_bits);
2456 _impl_.nr_taken_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2457 CHK_(ptr);
2458 } else {
2459 goto handle_unusual;
2460 }
2461 continue;
2462 default:
2463 goto handle_unusual;
2464 } // switch
2465 handle_unusual:
2466 if ((tag == 0) || ((tag & 7) == 4)) {
2467 CHK_(ptr);
2468 ctx->SetLastTag(tag);
2469 goto message_done;
2470 }
2471 ptr = UnknownFieldParse(
2472 tag,
2473 _internal_metadata_.mutable_unknown_fields<std::string>(),
2474 ptr, ctx);
2475 CHK_(ptr != nullptr);
2476 } // while
2477 message_done:
2478 _impl_._has_bits_.Or(has_bits);
2479 return ptr;
2480 failure:
2481 ptr = nullptr;
2482 goto message_done;
2483 #undef CHK_
2484 }
2485
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2486 ::uint8_t* MmCompactionIsolateFreepagesFtraceEvent::_InternalSerialize(
2487 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2488 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2489 ::uint32_t cached_has_bits = 0;
2490 (void) cached_has_bits;
2491
2492 cached_has_bits = _impl_._has_bits_[0];
2493 // optional uint64 start_pfn = 1;
2494 if (cached_has_bits & 0x00000001u) {
2495 target = stream->EnsureSpace(target);
2496 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_start_pfn(), target);
2497 }
2498
2499 // optional uint64 end_pfn = 2;
2500 if (cached_has_bits & 0x00000002u) {
2501 target = stream->EnsureSpace(target);
2502 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_end_pfn(), target);
2503 }
2504
2505 // optional uint64 nr_scanned = 3;
2506 if (cached_has_bits & 0x00000004u) {
2507 target = stream->EnsureSpace(target);
2508 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_nr_scanned(), target);
2509 }
2510
2511 // optional uint64 nr_taken = 4;
2512 if (cached_has_bits & 0x00000008u) {
2513 target = stream->EnsureSpace(target);
2514 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_nr_taken(), target);
2515 }
2516
2517 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2518 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2519 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2520 }
2521 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2522 return target;
2523 }
2524
ByteSizeLong() const2525 size_t MmCompactionIsolateFreepagesFtraceEvent::ByteSizeLong() const {
2526 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2527 size_t total_size = 0;
2528
2529 ::uint32_t cached_has_bits = 0;
2530 // Prevent compiler warnings about cached_has_bits being unused
2531 (void) cached_has_bits;
2532
2533 cached_has_bits = _impl_._has_bits_[0];
2534 if (cached_has_bits & 0x0000000fu) {
2535 // optional uint64 start_pfn = 1;
2536 if (cached_has_bits & 0x00000001u) {
2537 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_start_pfn());
2538 }
2539
2540 // optional uint64 end_pfn = 2;
2541 if (cached_has_bits & 0x00000002u) {
2542 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_end_pfn());
2543 }
2544
2545 // optional uint64 nr_scanned = 3;
2546 if (cached_has_bits & 0x00000004u) {
2547 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_scanned());
2548 }
2549
2550 // optional uint64 nr_taken = 4;
2551 if (cached_has_bits & 0x00000008u) {
2552 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_taken());
2553 }
2554
2555 }
2556 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2557 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2558 }
2559 int cached_size = ::_pbi::ToCachedSize(total_size);
2560 SetCachedSize(cached_size);
2561 return total_size;
2562 }
2563
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2564 void MmCompactionIsolateFreepagesFtraceEvent::CheckTypeAndMergeFrom(
2565 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2566 MergeFrom(*::_pbi::DownCast<const MmCompactionIsolateFreepagesFtraceEvent*>(
2567 &from));
2568 }
2569
MergeFrom(const MmCompactionIsolateFreepagesFtraceEvent & from)2570 void MmCompactionIsolateFreepagesFtraceEvent::MergeFrom(const MmCompactionIsolateFreepagesFtraceEvent& from) {
2571 MmCompactionIsolateFreepagesFtraceEvent* const _this = this;
2572 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2573 GOOGLE_DCHECK_NE(&from, _this);
2574 ::uint32_t cached_has_bits = 0;
2575 (void) cached_has_bits;
2576
2577 cached_has_bits = from._impl_._has_bits_[0];
2578 if (cached_has_bits & 0x0000000fu) {
2579 if (cached_has_bits & 0x00000001u) {
2580 _this->_impl_.start_pfn_ = from._impl_.start_pfn_;
2581 }
2582 if (cached_has_bits & 0x00000002u) {
2583 _this->_impl_.end_pfn_ = from._impl_.end_pfn_;
2584 }
2585 if (cached_has_bits & 0x00000004u) {
2586 _this->_impl_.nr_scanned_ = from._impl_.nr_scanned_;
2587 }
2588 if (cached_has_bits & 0x00000008u) {
2589 _this->_impl_.nr_taken_ = from._impl_.nr_taken_;
2590 }
2591 _this->_impl_._has_bits_[0] |= cached_has_bits;
2592 }
2593 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2594 }
2595
CopyFrom(const MmCompactionIsolateFreepagesFtraceEvent & from)2596 void MmCompactionIsolateFreepagesFtraceEvent::CopyFrom(const MmCompactionIsolateFreepagesFtraceEvent& from) {
2597 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent)
2598 if (&from == this) return;
2599 Clear();
2600 MergeFrom(from);
2601 }
2602
IsInitialized() const2603 bool MmCompactionIsolateFreepagesFtraceEvent::IsInitialized() const {
2604 return true;
2605 }
2606
InternalSwap(MmCompactionIsolateFreepagesFtraceEvent * other)2607 void MmCompactionIsolateFreepagesFtraceEvent::InternalSwap(MmCompactionIsolateFreepagesFtraceEvent* other) {
2608 using std::swap;
2609 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2610 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2611 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2612 PROTOBUF_FIELD_OFFSET(MmCompactionIsolateFreepagesFtraceEvent, _impl_.nr_taken_)
2613 + sizeof(MmCompactionIsolateFreepagesFtraceEvent::_impl_.nr_taken_) // NOLINT
2614 - PROTOBUF_FIELD_OFFSET(MmCompactionIsolateFreepagesFtraceEvent, _impl_.start_pfn_)>(
2615 reinterpret_cast<char*>(&_impl_.start_pfn_),
2616 reinterpret_cast<char*>(&other->_impl_.start_pfn_));
2617 }
2618
GetTypeName() const2619 std::string MmCompactionIsolateFreepagesFtraceEvent::GetTypeName() const {
2620 return "perfetto.protos.MmCompactionIsolateFreepagesFtraceEvent";
2621 }
2622
2623
2624 // ===================================================================
2625
2626 class MmCompactionIsolateMigratepagesFtraceEvent::_Internal {
2627 public:
2628 using HasBits = decltype(std::declval<MmCompactionIsolateMigratepagesFtraceEvent>()._impl_._has_bits_);
set_has_start_pfn(HasBits * has_bits)2629 static void set_has_start_pfn(HasBits* has_bits) {
2630 (*has_bits)[0] |= 1u;
2631 }
set_has_end_pfn(HasBits * has_bits)2632 static void set_has_end_pfn(HasBits* has_bits) {
2633 (*has_bits)[0] |= 2u;
2634 }
set_has_nr_scanned(HasBits * has_bits)2635 static void set_has_nr_scanned(HasBits* has_bits) {
2636 (*has_bits)[0] |= 4u;
2637 }
set_has_nr_taken(HasBits * has_bits)2638 static void set_has_nr_taken(HasBits* has_bits) {
2639 (*has_bits)[0] |= 8u;
2640 }
2641 };
2642
MmCompactionIsolateMigratepagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2643 MmCompactionIsolateMigratepagesFtraceEvent::MmCompactionIsolateMigratepagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2644 bool is_message_owned)
2645 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2646 SharedCtor(arena, is_message_owned);
2647 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2648 }
MmCompactionIsolateMigratepagesFtraceEvent(const MmCompactionIsolateMigratepagesFtraceEvent & from)2649 MmCompactionIsolateMigratepagesFtraceEvent::MmCompactionIsolateMigratepagesFtraceEvent(const MmCompactionIsolateMigratepagesFtraceEvent& from)
2650 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2651 MmCompactionIsolateMigratepagesFtraceEvent* const _this = this; (void)_this;
2652 new (&_impl_) Impl_{
2653 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2654 , /*decltype(_impl_._cached_size_)*/{}
2655 , decltype(_impl_.start_pfn_){}
2656 , decltype(_impl_.end_pfn_){}
2657 , decltype(_impl_.nr_scanned_){}
2658 , decltype(_impl_.nr_taken_){}};
2659
2660 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2661 ::memcpy(&_impl_.start_pfn_, &from._impl_.start_pfn_,
2662 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_taken_) -
2663 reinterpret_cast<char*>(&_impl_.start_pfn_)) + sizeof(_impl_.nr_taken_));
2664 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2665 }
2666
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2667 inline void MmCompactionIsolateMigratepagesFtraceEvent::SharedCtor(
2668 ::_pb::Arena* arena, bool is_message_owned) {
2669 (void)arena;
2670 (void)is_message_owned;
2671 new (&_impl_) Impl_{
2672 decltype(_impl_._has_bits_){}
2673 , /*decltype(_impl_._cached_size_)*/{}
2674 , decltype(_impl_.start_pfn_){::uint64_t{0u}}
2675 , decltype(_impl_.end_pfn_){::uint64_t{0u}}
2676 , decltype(_impl_.nr_scanned_){::uint64_t{0u}}
2677 , decltype(_impl_.nr_taken_){::uint64_t{0u}}
2678 };
2679 }
2680
~MmCompactionIsolateMigratepagesFtraceEvent()2681 MmCompactionIsolateMigratepagesFtraceEvent::~MmCompactionIsolateMigratepagesFtraceEvent() {
2682 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2683 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2684 (void)arena;
2685 return;
2686 }
2687 SharedDtor();
2688 }
2689
SharedDtor()2690 inline void MmCompactionIsolateMigratepagesFtraceEvent::SharedDtor() {
2691 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2692 }
2693
SetCachedSize(int size) const2694 void MmCompactionIsolateMigratepagesFtraceEvent::SetCachedSize(int size) const {
2695 _impl_._cached_size_.Set(size);
2696 }
2697
Clear()2698 void MmCompactionIsolateMigratepagesFtraceEvent::Clear() {
2699 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2700 ::uint32_t cached_has_bits = 0;
2701 // Prevent compiler warnings about cached_has_bits being unused
2702 (void) cached_has_bits;
2703
2704 cached_has_bits = _impl_._has_bits_[0];
2705 if (cached_has_bits & 0x0000000fu) {
2706 ::memset(&_impl_.start_pfn_, 0, static_cast<size_t>(
2707 reinterpret_cast<char*>(&_impl_.nr_taken_) -
2708 reinterpret_cast<char*>(&_impl_.start_pfn_)) + sizeof(_impl_.nr_taken_));
2709 }
2710 _impl_._has_bits_.Clear();
2711 _internal_metadata_.Clear<std::string>();
2712 }
2713
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2714 const char* MmCompactionIsolateMigratepagesFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2715 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2716 _Internal::HasBits has_bits{};
2717 while (!ctx->Done(&ptr)) {
2718 ::uint32_t tag;
2719 ptr = ::_pbi::ReadTag(ptr, &tag);
2720 switch (tag >> 3) {
2721 // optional uint64 start_pfn = 1;
2722 case 1:
2723 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2724 _Internal::set_has_start_pfn(&has_bits);
2725 _impl_.start_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2726 CHK_(ptr);
2727 } else {
2728 goto handle_unusual;
2729 }
2730 continue;
2731 // optional uint64 end_pfn = 2;
2732 case 2:
2733 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2734 _Internal::set_has_end_pfn(&has_bits);
2735 _impl_.end_pfn_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2736 CHK_(ptr);
2737 } else {
2738 goto handle_unusual;
2739 }
2740 continue;
2741 // optional uint64 nr_scanned = 3;
2742 case 3:
2743 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
2744 _Internal::set_has_nr_scanned(&has_bits);
2745 _impl_.nr_scanned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2746 CHK_(ptr);
2747 } else {
2748 goto handle_unusual;
2749 }
2750 continue;
2751 // optional uint64 nr_taken = 4;
2752 case 4:
2753 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2754 _Internal::set_has_nr_taken(&has_bits);
2755 _impl_.nr_taken_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
2756 CHK_(ptr);
2757 } else {
2758 goto handle_unusual;
2759 }
2760 continue;
2761 default:
2762 goto handle_unusual;
2763 } // switch
2764 handle_unusual:
2765 if ((tag == 0) || ((tag & 7) == 4)) {
2766 CHK_(ptr);
2767 ctx->SetLastTag(tag);
2768 goto message_done;
2769 }
2770 ptr = UnknownFieldParse(
2771 tag,
2772 _internal_metadata_.mutable_unknown_fields<std::string>(),
2773 ptr, ctx);
2774 CHK_(ptr != nullptr);
2775 } // while
2776 message_done:
2777 _impl_._has_bits_.Or(has_bits);
2778 return ptr;
2779 failure:
2780 ptr = nullptr;
2781 goto message_done;
2782 #undef CHK_
2783 }
2784
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2785 ::uint8_t* MmCompactionIsolateMigratepagesFtraceEvent::_InternalSerialize(
2786 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2787 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2788 ::uint32_t cached_has_bits = 0;
2789 (void) cached_has_bits;
2790
2791 cached_has_bits = _impl_._has_bits_[0];
2792 // optional uint64 start_pfn = 1;
2793 if (cached_has_bits & 0x00000001u) {
2794 target = stream->EnsureSpace(target);
2795 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_start_pfn(), target);
2796 }
2797
2798 // optional uint64 end_pfn = 2;
2799 if (cached_has_bits & 0x00000002u) {
2800 target = stream->EnsureSpace(target);
2801 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_end_pfn(), target);
2802 }
2803
2804 // optional uint64 nr_scanned = 3;
2805 if (cached_has_bits & 0x00000004u) {
2806 target = stream->EnsureSpace(target);
2807 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_nr_scanned(), target);
2808 }
2809
2810 // optional uint64 nr_taken = 4;
2811 if (cached_has_bits & 0x00000008u) {
2812 target = stream->EnsureSpace(target);
2813 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_nr_taken(), target);
2814 }
2815
2816 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2817 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2818 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2819 }
2820 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2821 return target;
2822 }
2823
ByteSizeLong() const2824 size_t MmCompactionIsolateMigratepagesFtraceEvent::ByteSizeLong() const {
2825 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2826 size_t total_size = 0;
2827
2828 ::uint32_t cached_has_bits = 0;
2829 // Prevent compiler warnings about cached_has_bits being unused
2830 (void) cached_has_bits;
2831
2832 cached_has_bits = _impl_._has_bits_[0];
2833 if (cached_has_bits & 0x0000000fu) {
2834 // optional uint64 start_pfn = 1;
2835 if (cached_has_bits & 0x00000001u) {
2836 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_start_pfn());
2837 }
2838
2839 // optional uint64 end_pfn = 2;
2840 if (cached_has_bits & 0x00000002u) {
2841 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_end_pfn());
2842 }
2843
2844 // optional uint64 nr_scanned = 3;
2845 if (cached_has_bits & 0x00000004u) {
2846 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_scanned());
2847 }
2848
2849 // optional uint64 nr_taken = 4;
2850 if (cached_has_bits & 0x00000008u) {
2851 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_taken());
2852 }
2853
2854 }
2855 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2856 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2857 }
2858 int cached_size = ::_pbi::ToCachedSize(total_size);
2859 SetCachedSize(cached_size);
2860 return total_size;
2861 }
2862
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2863 void MmCompactionIsolateMigratepagesFtraceEvent::CheckTypeAndMergeFrom(
2864 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2865 MergeFrom(*::_pbi::DownCast<const MmCompactionIsolateMigratepagesFtraceEvent*>(
2866 &from));
2867 }
2868
MergeFrom(const MmCompactionIsolateMigratepagesFtraceEvent & from)2869 void MmCompactionIsolateMigratepagesFtraceEvent::MergeFrom(const MmCompactionIsolateMigratepagesFtraceEvent& from) {
2870 MmCompactionIsolateMigratepagesFtraceEvent* const _this = this;
2871 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2872 GOOGLE_DCHECK_NE(&from, _this);
2873 ::uint32_t cached_has_bits = 0;
2874 (void) cached_has_bits;
2875
2876 cached_has_bits = from._impl_._has_bits_[0];
2877 if (cached_has_bits & 0x0000000fu) {
2878 if (cached_has_bits & 0x00000001u) {
2879 _this->_impl_.start_pfn_ = from._impl_.start_pfn_;
2880 }
2881 if (cached_has_bits & 0x00000002u) {
2882 _this->_impl_.end_pfn_ = from._impl_.end_pfn_;
2883 }
2884 if (cached_has_bits & 0x00000004u) {
2885 _this->_impl_.nr_scanned_ = from._impl_.nr_scanned_;
2886 }
2887 if (cached_has_bits & 0x00000008u) {
2888 _this->_impl_.nr_taken_ = from._impl_.nr_taken_;
2889 }
2890 _this->_impl_._has_bits_[0] |= cached_has_bits;
2891 }
2892 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2893 }
2894
CopyFrom(const MmCompactionIsolateMigratepagesFtraceEvent & from)2895 void MmCompactionIsolateMigratepagesFtraceEvent::CopyFrom(const MmCompactionIsolateMigratepagesFtraceEvent& from) {
2896 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent)
2897 if (&from == this) return;
2898 Clear();
2899 MergeFrom(from);
2900 }
2901
IsInitialized() const2902 bool MmCompactionIsolateMigratepagesFtraceEvent::IsInitialized() const {
2903 return true;
2904 }
2905
InternalSwap(MmCompactionIsolateMigratepagesFtraceEvent * other)2906 void MmCompactionIsolateMigratepagesFtraceEvent::InternalSwap(MmCompactionIsolateMigratepagesFtraceEvent* other) {
2907 using std::swap;
2908 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2909 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2910 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2911 PROTOBUF_FIELD_OFFSET(MmCompactionIsolateMigratepagesFtraceEvent, _impl_.nr_taken_)
2912 + sizeof(MmCompactionIsolateMigratepagesFtraceEvent::_impl_.nr_taken_) // NOLINT
2913 - PROTOBUF_FIELD_OFFSET(MmCompactionIsolateMigratepagesFtraceEvent, _impl_.start_pfn_)>(
2914 reinterpret_cast<char*>(&_impl_.start_pfn_),
2915 reinterpret_cast<char*>(&other->_impl_.start_pfn_));
2916 }
2917
GetTypeName() const2918 std::string MmCompactionIsolateMigratepagesFtraceEvent::GetTypeName() const {
2919 return "perfetto.protos.MmCompactionIsolateMigratepagesFtraceEvent";
2920 }
2921
2922
2923 // ===================================================================
2924
2925 class MmCompactionKcompactdSleepFtraceEvent::_Internal {
2926 public:
2927 using HasBits = decltype(std::declval<MmCompactionKcompactdSleepFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)2928 static void set_has_nid(HasBits* has_bits) {
2929 (*has_bits)[0] |= 1u;
2930 }
2931 };
2932
MmCompactionKcompactdSleepFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2933 MmCompactionKcompactdSleepFtraceEvent::MmCompactionKcompactdSleepFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2934 bool is_message_owned)
2935 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2936 SharedCtor(arena, is_message_owned);
2937 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
2938 }
MmCompactionKcompactdSleepFtraceEvent(const MmCompactionKcompactdSleepFtraceEvent & from)2939 MmCompactionKcompactdSleepFtraceEvent::MmCompactionKcompactdSleepFtraceEvent(const MmCompactionKcompactdSleepFtraceEvent& from)
2940 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2941 MmCompactionKcompactdSleepFtraceEvent* const _this = this; (void)_this;
2942 new (&_impl_) Impl_{
2943 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2944 , /*decltype(_impl_._cached_size_)*/{}
2945 , decltype(_impl_.nid_){}};
2946
2947 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2948 _this->_impl_.nid_ = from._impl_.nid_;
2949 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
2950 }
2951
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2952 inline void MmCompactionKcompactdSleepFtraceEvent::SharedCtor(
2953 ::_pb::Arena* arena, bool is_message_owned) {
2954 (void)arena;
2955 (void)is_message_owned;
2956 new (&_impl_) Impl_{
2957 decltype(_impl_._has_bits_){}
2958 , /*decltype(_impl_._cached_size_)*/{}
2959 , decltype(_impl_.nid_){0}
2960 };
2961 }
2962
~MmCompactionKcompactdSleepFtraceEvent()2963 MmCompactionKcompactdSleepFtraceEvent::~MmCompactionKcompactdSleepFtraceEvent() {
2964 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
2965 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2966 (void)arena;
2967 return;
2968 }
2969 SharedDtor();
2970 }
2971
SharedDtor()2972 inline void MmCompactionKcompactdSleepFtraceEvent::SharedDtor() {
2973 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2974 }
2975
SetCachedSize(int size) const2976 void MmCompactionKcompactdSleepFtraceEvent::SetCachedSize(int size) const {
2977 _impl_._cached_size_.Set(size);
2978 }
2979
Clear()2980 void MmCompactionKcompactdSleepFtraceEvent::Clear() {
2981 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
2982 ::uint32_t cached_has_bits = 0;
2983 // Prevent compiler warnings about cached_has_bits being unused
2984 (void) cached_has_bits;
2985
2986 _impl_.nid_ = 0;
2987 _impl_._has_bits_.Clear();
2988 _internal_metadata_.Clear<std::string>();
2989 }
2990
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2991 const char* MmCompactionKcompactdSleepFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2992 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2993 _Internal::HasBits has_bits{};
2994 while (!ctx->Done(&ptr)) {
2995 ::uint32_t tag;
2996 ptr = ::_pbi::ReadTag(ptr, &tag);
2997 switch (tag >> 3) {
2998 // optional int32 nid = 1;
2999 case 1:
3000 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3001 _Internal::set_has_nid(&has_bits);
3002 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3003 CHK_(ptr);
3004 } else {
3005 goto handle_unusual;
3006 }
3007 continue;
3008 default:
3009 goto handle_unusual;
3010 } // switch
3011 handle_unusual:
3012 if ((tag == 0) || ((tag & 7) == 4)) {
3013 CHK_(ptr);
3014 ctx->SetLastTag(tag);
3015 goto message_done;
3016 }
3017 ptr = UnknownFieldParse(
3018 tag,
3019 _internal_metadata_.mutable_unknown_fields<std::string>(),
3020 ptr, ctx);
3021 CHK_(ptr != nullptr);
3022 } // while
3023 message_done:
3024 _impl_._has_bits_.Or(has_bits);
3025 return ptr;
3026 failure:
3027 ptr = nullptr;
3028 goto message_done;
3029 #undef CHK_
3030 }
3031
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3032 ::uint8_t* MmCompactionKcompactdSleepFtraceEvent::_InternalSerialize(
3033 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3034 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
3035 ::uint32_t cached_has_bits = 0;
3036 (void) cached_has_bits;
3037
3038 cached_has_bits = _impl_._has_bits_[0];
3039 // optional int32 nid = 1;
3040 if (cached_has_bits & 0x00000001u) {
3041 target = stream->EnsureSpace(target);
3042 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
3043 }
3044
3045 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3046 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3047 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3048 }
3049 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
3050 return target;
3051 }
3052
ByteSizeLong() const3053 size_t MmCompactionKcompactdSleepFtraceEvent::ByteSizeLong() const {
3054 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
3055 size_t total_size = 0;
3056
3057 ::uint32_t cached_has_bits = 0;
3058 // Prevent compiler warnings about cached_has_bits being unused
3059 (void) cached_has_bits;
3060
3061 // optional int32 nid = 1;
3062 cached_has_bits = _impl_._has_bits_[0];
3063 if (cached_has_bits & 0x00000001u) {
3064 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
3065 }
3066
3067 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3068 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3069 }
3070 int cached_size = ::_pbi::ToCachedSize(total_size);
3071 SetCachedSize(cached_size);
3072 return total_size;
3073 }
3074
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3075 void MmCompactionKcompactdSleepFtraceEvent::CheckTypeAndMergeFrom(
3076 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3077 MergeFrom(*::_pbi::DownCast<const MmCompactionKcompactdSleepFtraceEvent*>(
3078 &from));
3079 }
3080
MergeFrom(const MmCompactionKcompactdSleepFtraceEvent & from)3081 void MmCompactionKcompactdSleepFtraceEvent::MergeFrom(const MmCompactionKcompactdSleepFtraceEvent& from) {
3082 MmCompactionKcompactdSleepFtraceEvent* const _this = this;
3083 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
3084 GOOGLE_DCHECK_NE(&from, _this);
3085 ::uint32_t cached_has_bits = 0;
3086 (void) cached_has_bits;
3087
3088 if (from._internal_has_nid()) {
3089 _this->_internal_set_nid(from._internal_nid());
3090 }
3091 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3092 }
3093
CopyFrom(const MmCompactionKcompactdSleepFtraceEvent & from)3094 void MmCompactionKcompactdSleepFtraceEvent::CopyFrom(const MmCompactionKcompactdSleepFtraceEvent& from) {
3095 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionKcompactdSleepFtraceEvent)
3096 if (&from == this) return;
3097 Clear();
3098 MergeFrom(from);
3099 }
3100
IsInitialized() const3101 bool MmCompactionKcompactdSleepFtraceEvent::IsInitialized() const {
3102 return true;
3103 }
3104
InternalSwap(MmCompactionKcompactdSleepFtraceEvent * other)3105 void MmCompactionKcompactdSleepFtraceEvent::InternalSwap(MmCompactionKcompactdSleepFtraceEvent* other) {
3106 using std::swap;
3107 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3108 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3109 swap(_impl_.nid_, other->_impl_.nid_);
3110 }
3111
GetTypeName() const3112 std::string MmCompactionKcompactdSleepFtraceEvent::GetTypeName() const {
3113 return "perfetto.protos.MmCompactionKcompactdSleepFtraceEvent";
3114 }
3115
3116
3117 // ===================================================================
3118
3119 class MmCompactionKcompactdWakeFtraceEvent::_Internal {
3120 public:
3121 using HasBits = decltype(std::declval<MmCompactionKcompactdWakeFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)3122 static void set_has_nid(HasBits* has_bits) {
3123 (*has_bits)[0] |= 1u;
3124 }
set_has_order(HasBits * has_bits)3125 static void set_has_order(HasBits* has_bits) {
3126 (*has_bits)[0] |= 2u;
3127 }
set_has_classzone_idx(HasBits * has_bits)3128 static void set_has_classzone_idx(HasBits* has_bits) {
3129 (*has_bits)[0] |= 4u;
3130 }
set_has_highest_zoneidx(HasBits * has_bits)3131 static void set_has_highest_zoneidx(HasBits* has_bits) {
3132 (*has_bits)[0] |= 8u;
3133 }
3134 };
3135
MmCompactionKcompactdWakeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3136 MmCompactionKcompactdWakeFtraceEvent::MmCompactionKcompactdWakeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3137 bool is_message_owned)
3138 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3139 SharedCtor(arena, is_message_owned);
3140 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3141 }
MmCompactionKcompactdWakeFtraceEvent(const MmCompactionKcompactdWakeFtraceEvent & from)3142 MmCompactionKcompactdWakeFtraceEvent::MmCompactionKcompactdWakeFtraceEvent(const MmCompactionKcompactdWakeFtraceEvent& from)
3143 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3144 MmCompactionKcompactdWakeFtraceEvent* const _this = this; (void)_this;
3145 new (&_impl_) Impl_{
3146 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3147 , /*decltype(_impl_._cached_size_)*/{}
3148 , decltype(_impl_.nid_){}
3149 , decltype(_impl_.order_){}
3150 , decltype(_impl_.classzone_idx_){}
3151 , decltype(_impl_.highest_zoneidx_){}};
3152
3153 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3154 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
3155 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.highest_zoneidx_) -
3156 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.highest_zoneidx_));
3157 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3158 }
3159
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3160 inline void MmCompactionKcompactdWakeFtraceEvent::SharedCtor(
3161 ::_pb::Arena* arena, bool is_message_owned) {
3162 (void)arena;
3163 (void)is_message_owned;
3164 new (&_impl_) Impl_{
3165 decltype(_impl_._has_bits_){}
3166 , /*decltype(_impl_._cached_size_)*/{}
3167 , decltype(_impl_.nid_){0}
3168 , decltype(_impl_.order_){0}
3169 , decltype(_impl_.classzone_idx_){0u}
3170 , decltype(_impl_.highest_zoneidx_){0u}
3171 };
3172 }
3173
~MmCompactionKcompactdWakeFtraceEvent()3174 MmCompactionKcompactdWakeFtraceEvent::~MmCompactionKcompactdWakeFtraceEvent() {
3175 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3176 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3177 (void)arena;
3178 return;
3179 }
3180 SharedDtor();
3181 }
3182
SharedDtor()3183 inline void MmCompactionKcompactdWakeFtraceEvent::SharedDtor() {
3184 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3185 }
3186
SetCachedSize(int size) const3187 void MmCompactionKcompactdWakeFtraceEvent::SetCachedSize(int size) const {
3188 _impl_._cached_size_.Set(size);
3189 }
3190
Clear()3191 void MmCompactionKcompactdWakeFtraceEvent::Clear() {
3192 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3193 ::uint32_t cached_has_bits = 0;
3194 // Prevent compiler warnings about cached_has_bits being unused
3195 (void) cached_has_bits;
3196
3197 cached_has_bits = _impl_._has_bits_[0];
3198 if (cached_has_bits & 0x0000000fu) {
3199 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
3200 reinterpret_cast<char*>(&_impl_.highest_zoneidx_) -
3201 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.highest_zoneidx_));
3202 }
3203 _impl_._has_bits_.Clear();
3204 _internal_metadata_.Clear<std::string>();
3205 }
3206
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3207 const char* MmCompactionKcompactdWakeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3208 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3209 _Internal::HasBits has_bits{};
3210 while (!ctx->Done(&ptr)) {
3211 ::uint32_t tag;
3212 ptr = ::_pbi::ReadTag(ptr, &tag);
3213 switch (tag >> 3) {
3214 // optional int32 nid = 1;
3215 case 1:
3216 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3217 _Internal::set_has_nid(&has_bits);
3218 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3219 CHK_(ptr);
3220 } else {
3221 goto handle_unusual;
3222 }
3223 continue;
3224 // optional int32 order = 2;
3225 case 2:
3226 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3227 _Internal::set_has_order(&has_bits);
3228 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3229 CHK_(ptr);
3230 } else {
3231 goto handle_unusual;
3232 }
3233 continue;
3234 // optional uint32 classzone_idx = 3;
3235 case 3:
3236 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3237 _Internal::set_has_classzone_idx(&has_bits);
3238 _impl_.classzone_idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3239 CHK_(ptr);
3240 } else {
3241 goto handle_unusual;
3242 }
3243 continue;
3244 // optional uint32 highest_zoneidx = 4;
3245 case 4:
3246 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3247 _Internal::set_has_highest_zoneidx(&has_bits);
3248 _impl_.highest_zoneidx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3249 CHK_(ptr);
3250 } else {
3251 goto handle_unusual;
3252 }
3253 continue;
3254 default:
3255 goto handle_unusual;
3256 } // switch
3257 handle_unusual:
3258 if ((tag == 0) || ((tag & 7) == 4)) {
3259 CHK_(ptr);
3260 ctx->SetLastTag(tag);
3261 goto message_done;
3262 }
3263 ptr = UnknownFieldParse(
3264 tag,
3265 _internal_metadata_.mutable_unknown_fields<std::string>(),
3266 ptr, ctx);
3267 CHK_(ptr != nullptr);
3268 } // while
3269 message_done:
3270 _impl_._has_bits_.Or(has_bits);
3271 return ptr;
3272 failure:
3273 ptr = nullptr;
3274 goto message_done;
3275 #undef CHK_
3276 }
3277
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3278 ::uint8_t* MmCompactionKcompactdWakeFtraceEvent::_InternalSerialize(
3279 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3280 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3281 ::uint32_t cached_has_bits = 0;
3282 (void) cached_has_bits;
3283
3284 cached_has_bits = _impl_._has_bits_[0];
3285 // optional int32 nid = 1;
3286 if (cached_has_bits & 0x00000001u) {
3287 target = stream->EnsureSpace(target);
3288 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
3289 }
3290
3291 // optional int32 order = 2;
3292 if (cached_has_bits & 0x00000002u) {
3293 target = stream->EnsureSpace(target);
3294 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_order(), target);
3295 }
3296
3297 // optional uint32 classzone_idx = 3;
3298 if (cached_has_bits & 0x00000004u) {
3299 target = stream->EnsureSpace(target);
3300 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_classzone_idx(), target);
3301 }
3302
3303 // optional uint32 highest_zoneidx = 4;
3304 if (cached_has_bits & 0x00000008u) {
3305 target = stream->EnsureSpace(target);
3306 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_highest_zoneidx(), target);
3307 }
3308
3309 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3310 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3311 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3312 }
3313 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3314 return target;
3315 }
3316
ByteSizeLong() const3317 size_t MmCompactionKcompactdWakeFtraceEvent::ByteSizeLong() const {
3318 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3319 size_t total_size = 0;
3320
3321 ::uint32_t cached_has_bits = 0;
3322 // Prevent compiler warnings about cached_has_bits being unused
3323 (void) cached_has_bits;
3324
3325 cached_has_bits = _impl_._has_bits_[0];
3326 if (cached_has_bits & 0x0000000fu) {
3327 // optional int32 nid = 1;
3328 if (cached_has_bits & 0x00000001u) {
3329 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
3330 }
3331
3332 // optional int32 order = 2;
3333 if (cached_has_bits & 0x00000002u) {
3334 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
3335 }
3336
3337 // optional uint32 classzone_idx = 3;
3338 if (cached_has_bits & 0x00000004u) {
3339 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_classzone_idx());
3340 }
3341
3342 // optional uint32 highest_zoneidx = 4;
3343 if (cached_has_bits & 0x00000008u) {
3344 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_highest_zoneidx());
3345 }
3346
3347 }
3348 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3349 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3350 }
3351 int cached_size = ::_pbi::ToCachedSize(total_size);
3352 SetCachedSize(cached_size);
3353 return total_size;
3354 }
3355
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3356 void MmCompactionKcompactdWakeFtraceEvent::CheckTypeAndMergeFrom(
3357 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3358 MergeFrom(*::_pbi::DownCast<const MmCompactionKcompactdWakeFtraceEvent*>(
3359 &from));
3360 }
3361
MergeFrom(const MmCompactionKcompactdWakeFtraceEvent & from)3362 void MmCompactionKcompactdWakeFtraceEvent::MergeFrom(const MmCompactionKcompactdWakeFtraceEvent& from) {
3363 MmCompactionKcompactdWakeFtraceEvent* const _this = this;
3364 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3365 GOOGLE_DCHECK_NE(&from, _this);
3366 ::uint32_t cached_has_bits = 0;
3367 (void) cached_has_bits;
3368
3369 cached_has_bits = from._impl_._has_bits_[0];
3370 if (cached_has_bits & 0x0000000fu) {
3371 if (cached_has_bits & 0x00000001u) {
3372 _this->_impl_.nid_ = from._impl_.nid_;
3373 }
3374 if (cached_has_bits & 0x00000002u) {
3375 _this->_impl_.order_ = from._impl_.order_;
3376 }
3377 if (cached_has_bits & 0x00000004u) {
3378 _this->_impl_.classzone_idx_ = from._impl_.classzone_idx_;
3379 }
3380 if (cached_has_bits & 0x00000008u) {
3381 _this->_impl_.highest_zoneidx_ = from._impl_.highest_zoneidx_;
3382 }
3383 _this->_impl_._has_bits_[0] |= cached_has_bits;
3384 }
3385 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3386 }
3387
CopyFrom(const MmCompactionKcompactdWakeFtraceEvent & from)3388 void MmCompactionKcompactdWakeFtraceEvent::CopyFrom(const MmCompactionKcompactdWakeFtraceEvent& from) {
3389 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionKcompactdWakeFtraceEvent)
3390 if (&from == this) return;
3391 Clear();
3392 MergeFrom(from);
3393 }
3394
IsInitialized() const3395 bool MmCompactionKcompactdWakeFtraceEvent::IsInitialized() const {
3396 return true;
3397 }
3398
InternalSwap(MmCompactionKcompactdWakeFtraceEvent * other)3399 void MmCompactionKcompactdWakeFtraceEvent::InternalSwap(MmCompactionKcompactdWakeFtraceEvent* other) {
3400 using std::swap;
3401 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3402 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3403 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3404 PROTOBUF_FIELD_OFFSET(MmCompactionKcompactdWakeFtraceEvent, _impl_.highest_zoneidx_)
3405 + sizeof(MmCompactionKcompactdWakeFtraceEvent::_impl_.highest_zoneidx_) // NOLINT
3406 - PROTOBUF_FIELD_OFFSET(MmCompactionKcompactdWakeFtraceEvent, _impl_.nid_)>(
3407 reinterpret_cast<char*>(&_impl_.nid_),
3408 reinterpret_cast<char*>(&other->_impl_.nid_));
3409 }
3410
GetTypeName() const3411 std::string MmCompactionKcompactdWakeFtraceEvent::GetTypeName() const {
3412 return "perfetto.protos.MmCompactionKcompactdWakeFtraceEvent";
3413 }
3414
3415
3416 // ===================================================================
3417
3418 class MmCompactionMigratepagesFtraceEvent::_Internal {
3419 public:
3420 using HasBits = decltype(std::declval<MmCompactionMigratepagesFtraceEvent>()._impl_._has_bits_);
set_has_nr_migrated(HasBits * has_bits)3421 static void set_has_nr_migrated(HasBits* has_bits) {
3422 (*has_bits)[0] |= 1u;
3423 }
set_has_nr_failed(HasBits * has_bits)3424 static void set_has_nr_failed(HasBits* has_bits) {
3425 (*has_bits)[0] |= 2u;
3426 }
3427 };
3428
MmCompactionMigratepagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3429 MmCompactionMigratepagesFtraceEvent::MmCompactionMigratepagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3430 bool is_message_owned)
3431 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3432 SharedCtor(arena, is_message_owned);
3433 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3434 }
MmCompactionMigratepagesFtraceEvent(const MmCompactionMigratepagesFtraceEvent & from)3435 MmCompactionMigratepagesFtraceEvent::MmCompactionMigratepagesFtraceEvent(const MmCompactionMigratepagesFtraceEvent& from)
3436 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3437 MmCompactionMigratepagesFtraceEvent* const _this = this; (void)_this;
3438 new (&_impl_) Impl_{
3439 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3440 , /*decltype(_impl_._cached_size_)*/{}
3441 , decltype(_impl_.nr_migrated_){}
3442 , decltype(_impl_.nr_failed_){}};
3443
3444 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3445 ::memcpy(&_impl_.nr_migrated_, &from._impl_.nr_migrated_,
3446 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.nr_failed_) -
3447 reinterpret_cast<char*>(&_impl_.nr_migrated_)) + sizeof(_impl_.nr_failed_));
3448 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3449 }
3450
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3451 inline void MmCompactionMigratepagesFtraceEvent::SharedCtor(
3452 ::_pb::Arena* arena, bool is_message_owned) {
3453 (void)arena;
3454 (void)is_message_owned;
3455 new (&_impl_) Impl_{
3456 decltype(_impl_._has_bits_){}
3457 , /*decltype(_impl_._cached_size_)*/{}
3458 , decltype(_impl_.nr_migrated_){::uint64_t{0u}}
3459 , decltype(_impl_.nr_failed_){::uint64_t{0u}}
3460 };
3461 }
3462
~MmCompactionMigratepagesFtraceEvent()3463 MmCompactionMigratepagesFtraceEvent::~MmCompactionMigratepagesFtraceEvent() {
3464 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3465 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3466 (void)arena;
3467 return;
3468 }
3469 SharedDtor();
3470 }
3471
SharedDtor()3472 inline void MmCompactionMigratepagesFtraceEvent::SharedDtor() {
3473 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3474 }
3475
SetCachedSize(int size) const3476 void MmCompactionMigratepagesFtraceEvent::SetCachedSize(int size) const {
3477 _impl_._cached_size_.Set(size);
3478 }
3479
Clear()3480 void MmCompactionMigratepagesFtraceEvent::Clear() {
3481 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3482 ::uint32_t cached_has_bits = 0;
3483 // Prevent compiler warnings about cached_has_bits being unused
3484 (void) cached_has_bits;
3485
3486 cached_has_bits = _impl_._has_bits_[0];
3487 if (cached_has_bits & 0x00000003u) {
3488 ::memset(&_impl_.nr_migrated_, 0, static_cast<size_t>(
3489 reinterpret_cast<char*>(&_impl_.nr_failed_) -
3490 reinterpret_cast<char*>(&_impl_.nr_migrated_)) + sizeof(_impl_.nr_failed_));
3491 }
3492 _impl_._has_bits_.Clear();
3493 _internal_metadata_.Clear<std::string>();
3494 }
3495
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3496 const char* MmCompactionMigratepagesFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3497 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3498 _Internal::HasBits has_bits{};
3499 while (!ctx->Done(&ptr)) {
3500 ::uint32_t tag;
3501 ptr = ::_pbi::ReadTag(ptr, &tag);
3502 switch (tag >> 3) {
3503 // optional uint64 nr_migrated = 1;
3504 case 1:
3505 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3506 _Internal::set_has_nr_migrated(&has_bits);
3507 _impl_.nr_migrated_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3508 CHK_(ptr);
3509 } else {
3510 goto handle_unusual;
3511 }
3512 continue;
3513 // optional uint64 nr_failed = 2;
3514 case 2:
3515 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3516 _Internal::set_has_nr_failed(&has_bits);
3517 _impl_.nr_failed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
3518 CHK_(ptr);
3519 } else {
3520 goto handle_unusual;
3521 }
3522 continue;
3523 default:
3524 goto handle_unusual;
3525 } // switch
3526 handle_unusual:
3527 if ((tag == 0) || ((tag & 7) == 4)) {
3528 CHK_(ptr);
3529 ctx->SetLastTag(tag);
3530 goto message_done;
3531 }
3532 ptr = UnknownFieldParse(
3533 tag,
3534 _internal_metadata_.mutable_unknown_fields<std::string>(),
3535 ptr, ctx);
3536 CHK_(ptr != nullptr);
3537 } // while
3538 message_done:
3539 _impl_._has_bits_.Or(has_bits);
3540 return ptr;
3541 failure:
3542 ptr = nullptr;
3543 goto message_done;
3544 #undef CHK_
3545 }
3546
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3547 ::uint8_t* MmCompactionMigratepagesFtraceEvent::_InternalSerialize(
3548 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3549 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3550 ::uint32_t cached_has_bits = 0;
3551 (void) cached_has_bits;
3552
3553 cached_has_bits = _impl_._has_bits_[0];
3554 // optional uint64 nr_migrated = 1;
3555 if (cached_has_bits & 0x00000001u) {
3556 target = stream->EnsureSpace(target);
3557 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_nr_migrated(), target);
3558 }
3559
3560 // optional uint64 nr_failed = 2;
3561 if (cached_has_bits & 0x00000002u) {
3562 target = stream->EnsureSpace(target);
3563 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_nr_failed(), target);
3564 }
3565
3566 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3567 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3568 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3569 }
3570 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3571 return target;
3572 }
3573
ByteSizeLong() const3574 size_t MmCompactionMigratepagesFtraceEvent::ByteSizeLong() const {
3575 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3576 size_t total_size = 0;
3577
3578 ::uint32_t cached_has_bits = 0;
3579 // Prevent compiler warnings about cached_has_bits being unused
3580 (void) cached_has_bits;
3581
3582 cached_has_bits = _impl_._has_bits_[0];
3583 if (cached_has_bits & 0x00000003u) {
3584 // optional uint64 nr_migrated = 1;
3585 if (cached_has_bits & 0x00000001u) {
3586 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_migrated());
3587 }
3588
3589 // optional uint64 nr_failed = 2;
3590 if (cached_has_bits & 0x00000002u) {
3591 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_failed());
3592 }
3593
3594 }
3595 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3596 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3597 }
3598 int cached_size = ::_pbi::ToCachedSize(total_size);
3599 SetCachedSize(cached_size);
3600 return total_size;
3601 }
3602
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3603 void MmCompactionMigratepagesFtraceEvent::CheckTypeAndMergeFrom(
3604 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3605 MergeFrom(*::_pbi::DownCast<const MmCompactionMigratepagesFtraceEvent*>(
3606 &from));
3607 }
3608
MergeFrom(const MmCompactionMigratepagesFtraceEvent & from)3609 void MmCompactionMigratepagesFtraceEvent::MergeFrom(const MmCompactionMigratepagesFtraceEvent& from) {
3610 MmCompactionMigratepagesFtraceEvent* const _this = this;
3611 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3612 GOOGLE_DCHECK_NE(&from, _this);
3613 ::uint32_t cached_has_bits = 0;
3614 (void) cached_has_bits;
3615
3616 cached_has_bits = from._impl_._has_bits_[0];
3617 if (cached_has_bits & 0x00000003u) {
3618 if (cached_has_bits & 0x00000001u) {
3619 _this->_impl_.nr_migrated_ = from._impl_.nr_migrated_;
3620 }
3621 if (cached_has_bits & 0x00000002u) {
3622 _this->_impl_.nr_failed_ = from._impl_.nr_failed_;
3623 }
3624 _this->_impl_._has_bits_[0] |= cached_has_bits;
3625 }
3626 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3627 }
3628
CopyFrom(const MmCompactionMigratepagesFtraceEvent & from)3629 void MmCompactionMigratepagesFtraceEvent::CopyFrom(const MmCompactionMigratepagesFtraceEvent& from) {
3630 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionMigratepagesFtraceEvent)
3631 if (&from == this) return;
3632 Clear();
3633 MergeFrom(from);
3634 }
3635
IsInitialized() const3636 bool MmCompactionMigratepagesFtraceEvent::IsInitialized() const {
3637 return true;
3638 }
3639
InternalSwap(MmCompactionMigratepagesFtraceEvent * other)3640 void MmCompactionMigratepagesFtraceEvent::InternalSwap(MmCompactionMigratepagesFtraceEvent* other) {
3641 using std::swap;
3642 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3643 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3644 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3645 PROTOBUF_FIELD_OFFSET(MmCompactionMigratepagesFtraceEvent, _impl_.nr_failed_)
3646 + sizeof(MmCompactionMigratepagesFtraceEvent::_impl_.nr_failed_) // NOLINT
3647 - PROTOBUF_FIELD_OFFSET(MmCompactionMigratepagesFtraceEvent, _impl_.nr_migrated_)>(
3648 reinterpret_cast<char*>(&_impl_.nr_migrated_),
3649 reinterpret_cast<char*>(&other->_impl_.nr_migrated_));
3650 }
3651
GetTypeName() const3652 std::string MmCompactionMigratepagesFtraceEvent::GetTypeName() const {
3653 return "perfetto.protos.MmCompactionMigratepagesFtraceEvent";
3654 }
3655
3656
3657 // ===================================================================
3658
3659 class MmCompactionSuitableFtraceEvent::_Internal {
3660 public:
3661 using HasBits = decltype(std::declval<MmCompactionSuitableFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)3662 static void set_has_nid(HasBits* has_bits) {
3663 (*has_bits)[0] |= 1u;
3664 }
set_has_idx(HasBits * has_bits)3665 static void set_has_idx(HasBits* has_bits) {
3666 (*has_bits)[0] |= 2u;
3667 }
set_has_order(HasBits * has_bits)3668 static void set_has_order(HasBits* has_bits) {
3669 (*has_bits)[0] |= 4u;
3670 }
set_has_ret(HasBits * has_bits)3671 static void set_has_ret(HasBits* has_bits) {
3672 (*has_bits)[0] |= 8u;
3673 }
3674 };
3675
MmCompactionSuitableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3676 MmCompactionSuitableFtraceEvent::MmCompactionSuitableFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3677 bool is_message_owned)
3678 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3679 SharedCtor(arena, is_message_owned);
3680 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionSuitableFtraceEvent)
3681 }
MmCompactionSuitableFtraceEvent(const MmCompactionSuitableFtraceEvent & from)3682 MmCompactionSuitableFtraceEvent::MmCompactionSuitableFtraceEvent(const MmCompactionSuitableFtraceEvent& from)
3683 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3684 MmCompactionSuitableFtraceEvent* const _this = this; (void)_this;
3685 new (&_impl_) Impl_{
3686 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3687 , /*decltype(_impl_._cached_size_)*/{}
3688 , decltype(_impl_.nid_){}
3689 , decltype(_impl_.idx_){}
3690 , decltype(_impl_.order_){}
3691 , decltype(_impl_.ret_){}};
3692
3693 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3694 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
3695 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ret_) -
3696 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.ret_));
3697 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionSuitableFtraceEvent)
3698 }
3699
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3700 inline void MmCompactionSuitableFtraceEvent::SharedCtor(
3701 ::_pb::Arena* arena, bool is_message_owned) {
3702 (void)arena;
3703 (void)is_message_owned;
3704 new (&_impl_) Impl_{
3705 decltype(_impl_._has_bits_){}
3706 , /*decltype(_impl_._cached_size_)*/{}
3707 , decltype(_impl_.nid_){0}
3708 , decltype(_impl_.idx_){0u}
3709 , decltype(_impl_.order_){0}
3710 , decltype(_impl_.ret_){0}
3711 };
3712 }
3713
~MmCompactionSuitableFtraceEvent()3714 MmCompactionSuitableFtraceEvent::~MmCompactionSuitableFtraceEvent() {
3715 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionSuitableFtraceEvent)
3716 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3717 (void)arena;
3718 return;
3719 }
3720 SharedDtor();
3721 }
3722
SharedDtor()3723 inline void MmCompactionSuitableFtraceEvent::SharedDtor() {
3724 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3725 }
3726
SetCachedSize(int size) const3727 void MmCompactionSuitableFtraceEvent::SetCachedSize(int size) const {
3728 _impl_._cached_size_.Set(size);
3729 }
3730
Clear()3731 void MmCompactionSuitableFtraceEvent::Clear() {
3732 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionSuitableFtraceEvent)
3733 ::uint32_t cached_has_bits = 0;
3734 // Prevent compiler warnings about cached_has_bits being unused
3735 (void) cached_has_bits;
3736
3737 cached_has_bits = _impl_._has_bits_[0];
3738 if (cached_has_bits & 0x0000000fu) {
3739 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
3740 reinterpret_cast<char*>(&_impl_.ret_) -
3741 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.ret_));
3742 }
3743 _impl_._has_bits_.Clear();
3744 _internal_metadata_.Clear<std::string>();
3745 }
3746
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3747 const char* MmCompactionSuitableFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3748 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3749 _Internal::HasBits has_bits{};
3750 while (!ctx->Done(&ptr)) {
3751 ::uint32_t tag;
3752 ptr = ::_pbi::ReadTag(ptr, &tag);
3753 switch (tag >> 3) {
3754 // optional int32 nid = 1;
3755 case 1:
3756 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3757 _Internal::set_has_nid(&has_bits);
3758 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3759 CHK_(ptr);
3760 } else {
3761 goto handle_unusual;
3762 }
3763 continue;
3764 // optional uint32 idx = 2;
3765 case 2:
3766 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3767 _Internal::set_has_idx(&has_bits);
3768 _impl_.idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3769 CHK_(ptr);
3770 } else {
3771 goto handle_unusual;
3772 }
3773 continue;
3774 // optional int32 order = 3;
3775 case 3:
3776 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
3777 _Internal::set_has_order(&has_bits);
3778 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3779 CHK_(ptr);
3780 } else {
3781 goto handle_unusual;
3782 }
3783 continue;
3784 // optional int32 ret = 4;
3785 case 4:
3786 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
3787 _Internal::set_has_ret(&has_bits);
3788 _impl_.ret_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3789 CHK_(ptr);
3790 } else {
3791 goto handle_unusual;
3792 }
3793 continue;
3794 default:
3795 goto handle_unusual;
3796 } // switch
3797 handle_unusual:
3798 if ((tag == 0) || ((tag & 7) == 4)) {
3799 CHK_(ptr);
3800 ctx->SetLastTag(tag);
3801 goto message_done;
3802 }
3803 ptr = UnknownFieldParse(
3804 tag,
3805 _internal_metadata_.mutable_unknown_fields<std::string>(),
3806 ptr, ctx);
3807 CHK_(ptr != nullptr);
3808 } // while
3809 message_done:
3810 _impl_._has_bits_.Or(has_bits);
3811 return ptr;
3812 failure:
3813 ptr = nullptr;
3814 goto message_done;
3815 #undef CHK_
3816 }
3817
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3818 ::uint8_t* MmCompactionSuitableFtraceEvent::_InternalSerialize(
3819 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3820 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionSuitableFtraceEvent)
3821 ::uint32_t cached_has_bits = 0;
3822 (void) cached_has_bits;
3823
3824 cached_has_bits = _impl_._has_bits_[0];
3825 // optional int32 nid = 1;
3826 if (cached_has_bits & 0x00000001u) {
3827 target = stream->EnsureSpace(target);
3828 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
3829 }
3830
3831 // optional uint32 idx = 2;
3832 if (cached_has_bits & 0x00000002u) {
3833 target = stream->EnsureSpace(target);
3834 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_idx(), target);
3835 }
3836
3837 // optional int32 order = 3;
3838 if (cached_has_bits & 0x00000004u) {
3839 target = stream->EnsureSpace(target);
3840 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_order(), target);
3841 }
3842
3843 // optional int32 ret = 4;
3844 if (cached_has_bits & 0x00000008u) {
3845 target = stream->EnsureSpace(target);
3846 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_ret(), target);
3847 }
3848
3849 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3850 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3851 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3852 }
3853 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionSuitableFtraceEvent)
3854 return target;
3855 }
3856
ByteSizeLong() const3857 size_t MmCompactionSuitableFtraceEvent::ByteSizeLong() const {
3858 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionSuitableFtraceEvent)
3859 size_t total_size = 0;
3860
3861 ::uint32_t cached_has_bits = 0;
3862 // Prevent compiler warnings about cached_has_bits being unused
3863 (void) cached_has_bits;
3864
3865 cached_has_bits = _impl_._has_bits_[0];
3866 if (cached_has_bits & 0x0000000fu) {
3867 // optional int32 nid = 1;
3868 if (cached_has_bits & 0x00000001u) {
3869 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
3870 }
3871
3872 // optional uint32 idx = 2;
3873 if (cached_has_bits & 0x00000002u) {
3874 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_idx());
3875 }
3876
3877 // optional int32 order = 3;
3878 if (cached_has_bits & 0x00000004u) {
3879 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
3880 }
3881
3882 // optional int32 ret = 4;
3883 if (cached_has_bits & 0x00000008u) {
3884 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_ret());
3885 }
3886
3887 }
3888 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3889 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3890 }
3891 int cached_size = ::_pbi::ToCachedSize(total_size);
3892 SetCachedSize(cached_size);
3893 return total_size;
3894 }
3895
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3896 void MmCompactionSuitableFtraceEvent::CheckTypeAndMergeFrom(
3897 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3898 MergeFrom(*::_pbi::DownCast<const MmCompactionSuitableFtraceEvent*>(
3899 &from));
3900 }
3901
MergeFrom(const MmCompactionSuitableFtraceEvent & from)3902 void MmCompactionSuitableFtraceEvent::MergeFrom(const MmCompactionSuitableFtraceEvent& from) {
3903 MmCompactionSuitableFtraceEvent* const _this = this;
3904 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionSuitableFtraceEvent)
3905 GOOGLE_DCHECK_NE(&from, _this);
3906 ::uint32_t cached_has_bits = 0;
3907 (void) cached_has_bits;
3908
3909 cached_has_bits = from._impl_._has_bits_[0];
3910 if (cached_has_bits & 0x0000000fu) {
3911 if (cached_has_bits & 0x00000001u) {
3912 _this->_impl_.nid_ = from._impl_.nid_;
3913 }
3914 if (cached_has_bits & 0x00000002u) {
3915 _this->_impl_.idx_ = from._impl_.idx_;
3916 }
3917 if (cached_has_bits & 0x00000004u) {
3918 _this->_impl_.order_ = from._impl_.order_;
3919 }
3920 if (cached_has_bits & 0x00000008u) {
3921 _this->_impl_.ret_ = from._impl_.ret_;
3922 }
3923 _this->_impl_._has_bits_[0] |= cached_has_bits;
3924 }
3925 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3926 }
3927
CopyFrom(const MmCompactionSuitableFtraceEvent & from)3928 void MmCompactionSuitableFtraceEvent::CopyFrom(const MmCompactionSuitableFtraceEvent& from) {
3929 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionSuitableFtraceEvent)
3930 if (&from == this) return;
3931 Clear();
3932 MergeFrom(from);
3933 }
3934
IsInitialized() const3935 bool MmCompactionSuitableFtraceEvent::IsInitialized() const {
3936 return true;
3937 }
3938
InternalSwap(MmCompactionSuitableFtraceEvent * other)3939 void MmCompactionSuitableFtraceEvent::InternalSwap(MmCompactionSuitableFtraceEvent* other) {
3940 using std::swap;
3941 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3942 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3943 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3944 PROTOBUF_FIELD_OFFSET(MmCompactionSuitableFtraceEvent, _impl_.ret_)
3945 + sizeof(MmCompactionSuitableFtraceEvent::_impl_.ret_) // NOLINT
3946 - PROTOBUF_FIELD_OFFSET(MmCompactionSuitableFtraceEvent, _impl_.nid_)>(
3947 reinterpret_cast<char*>(&_impl_.nid_),
3948 reinterpret_cast<char*>(&other->_impl_.nid_));
3949 }
3950
GetTypeName() const3951 std::string MmCompactionSuitableFtraceEvent::GetTypeName() const {
3952 return "perfetto.protos.MmCompactionSuitableFtraceEvent";
3953 }
3954
3955
3956 // ===================================================================
3957
3958 class MmCompactionTryToCompactPagesFtraceEvent::_Internal {
3959 public:
3960 using HasBits = decltype(std::declval<MmCompactionTryToCompactPagesFtraceEvent>()._impl_._has_bits_);
set_has_order(HasBits * has_bits)3961 static void set_has_order(HasBits* has_bits) {
3962 (*has_bits)[0] |= 1u;
3963 }
set_has_gfp_mask(HasBits * has_bits)3964 static void set_has_gfp_mask(HasBits* has_bits) {
3965 (*has_bits)[0] |= 2u;
3966 }
set_has_mode(HasBits * has_bits)3967 static void set_has_mode(HasBits* has_bits) {
3968 (*has_bits)[0] |= 4u;
3969 }
set_has_prio(HasBits * has_bits)3970 static void set_has_prio(HasBits* has_bits) {
3971 (*has_bits)[0] |= 8u;
3972 }
3973 };
3974
MmCompactionTryToCompactPagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3975 MmCompactionTryToCompactPagesFtraceEvent::MmCompactionTryToCompactPagesFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3976 bool is_message_owned)
3977 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3978 SharedCtor(arena, is_message_owned);
3979 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
3980 }
MmCompactionTryToCompactPagesFtraceEvent(const MmCompactionTryToCompactPagesFtraceEvent & from)3981 MmCompactionTryToCompactPagesFtraceEvent::MmCompactionTryToCompactPagesFtraceEvent(const MmCompactionTryToCompactPagesFtraceEvent& from)
3982 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3983 MmCompactionTryToCompactPagesFtraceEvent* const _this = this; (void)_this;
3984 new (&_impl_) Impl_{
3985 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3986 , /*decltype(_impl_._cached_size_)*/{}
3987 , decltype(_impl_.order_){}
3988 , decltype(_impl_.gfp_mask_){}
3989 , decltype(_impl_.mode_){}
3990 , decltype(_impl_.prio_){}};
3991
3992 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3993 ::memcpy(&_impl_.order_, &from._impl_.order_,
3994 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
3995 reinterpret_cast<char*>(&_impl_.order_)) + sizeof(_impl_.prio_));
3996 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
3997 }
3998
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3999 inline void MmCompactionTryToCompactPagesFtraceEvent::SharedCtor(
4000 ::_pb::Arena* arena, bool is_message_owned) {
4001 (void)arena;
4002 (void)is_message_owned;
4003 new (&_impl_) Impl_{
4004 decltype(_impl_._has_bits_){}
4005 , /*decltype(_impl_._cached_size_)*/{}
4006 , decltype(_impl_.order_){0}
4007 , decltype(_impl_.gfp_mask_){0u}
4008 , decltype(_impl_.mode_){0u}
4009 , decltype(_impl_.prio_){0}
4010 };
4011 }
4012
~MmCompactionTryToCompactPagesFtraceEvent()4013 MmCompactionTryToCompactPagesFtraceEvent::~MmCompactionTryToCompactPagesFtraceEvent() {
4014 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4015 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4016 (void)arena;
4017 return;
4018 }
4019 SharedDtor();
4020 }
4021
SharedDtor()4022 inline void MmCompactionTryToCompactPagesFtraceEvent::SharedDtor() {
4023 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4024 }
4025
SetCachedSize(int size) const4026 void MmCompactionTryToCompactPagesFtraceEvent::SetCachedSize(int size) const {
4027 _impl_._cached_size_.Set(size);
4028 }
4029
Clear()4030 void MmCompactionTryToCompactPagesFtraceEvent::Clear() {
4031 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4032 ::uint32_t cached_has_bits = 0;
4033 // Prevent compiler warnings about cached_has_bits being unused
4034 (void) cached_has_bits;
4035
4036 cached_has_bits = _impl_._has_bits_[0];
4037 if (cached_has_bits & 0x0000000fu) {
4038 ::memset(&_impl_.order_, 0, static_cast<size_t>(
4039 reinterpret_cast<char*>(&_impl_.prio_) -
4040 reinterpret_cast<char*>(&_impl_.order_)) + sizeof(_impl_.prio_));
4041 }
4042 _impl_._has_bits_.Clear();
4043 _internal_metadata_.Clear<std::string>();
4044 }
4045
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4046 const char* MmCompactionTryToCompactPagesFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4047 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4048 _Internal::HasBits has_bits{};
4049 while (!ctx->Done(&ptr)) {
4050 ::uint32_t tag;
4051 ptr = ::_pbi::ReadTag(ptr, &tag);
4052 switch (tag >> 3) {
4053 // optional int32 order = 1;
4054 case 1:
4055 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4056 _Internal::set_has_order(&has_bits);
4057 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4058 CHK_(ptr);
4059 } else {
4060 goto handle_unusual;
4061 }
4062 continue;
4063 // optional uint32 gfp_mask = 2;
4064 case 2:
4065 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4066 _Internal::set_has_gfp_mask(&has_bits);
4067 _impl_.gfp_mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4068 CHK_(ptr);
4069 } else {
4070 goto handle_unusual;
4071 }
4072 continue;
4073 // optional uint32 mode = 3;
4074 case 3:
4075 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4076 _Internal::set_has_mode(&has_bits);
4077 _impl_.mode_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4078 CHK_(ptr);
4079 } else {
4080 goto handle_unusual;
4081 }
4082 continue;
4083 // optional int32 prio = 4;
4084 case 4:
4085 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4086 _Internal::set_has_prio(&has_bits);
4087 _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4088 CHK_(ptr);
4089 } else {
4090 goto handle_unusual;
4091 }
4092 continue;
4093 default:
4094 goto handle_unusual;
4095 } // switch
4096 handle_unusual:
4097 if ((tag == 0) || ((tag & 7) == 4)) {
4098 CHK_(ptr);
4099 ctx->SetLastTag(tag);
4100 goto message_done;
4101 }
4102 ptr = UnknownFieldParse(
4103 tag,
4104 _internal_metadata_.mutable_unknown_fields<std::string>(),
4105 ptr, ctx);
4106 CHK_(ptr != nullptr);
4107 } // while
4108 message_done:
4109 _impl_._has_bits_.Or(has_bits);
4110 return ptr;
4111 failure:
4112 ptr = nullptr;
4113 goto message_done;
4114 #undef CHK_
4115 }
4116
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4117 ::uint8_t* MmCompactionTryToCompactPagesFtraceEvent::_InternalSerialize(
4118 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4119 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4120 ::uint32_t cached_has_bits = 0;
4121 (void) cached_has_bits;
4122
4123 cached_has_bits = _impl_._has_bits_[0];
4124 // optional int32 order = 1;
4125 if (cached_has_bits & 0x00000001u) {
4126 target = stream->EnsureSpace(target);
4127 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_order(), target);
4128 }
4129
4130 // optional uint32 gfp_mask = 2;
4131 if (cached_has_bits & 0x00000002u) {
4132 target = stream->EnsureSpace(target);
4133 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_gfp_mask(), target);
4134 }
4135
4136 // optional uint32 mode = 3;
4137 if (cached_has_bits & 0x00000004u) {
4138 target = stream->EnsureSpace(target);
4139 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_mode(), target);
4140 }
4141
4142 // optional int32 prio = 4;
4143 if (cached_has_bits & 0x00000008u) {
4144 target = stream->EnsureSpace(target);
4145 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_prio(), target);
4146 }
4147
4148 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4149 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4150 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4151 }
4152 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4153 return target;
4154 }
4155
ByteSizeLong() const4156 size_t MmCompactionTryToCompactPagesFtraceEvent::ByteSizeLong() const {
4157 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4158 size_t total_size = 0;
4159
4160 ::uint32_t cached_has_bits = 0;
4161 // Prevent compiler warnings about cached_has_bits being unused
4162 (void) cached_has_bits;
4163
4164 cached_has_bits = _impl_._has_bits_[0];
4165 if (cached_has_bits & 0x0000000fu) {
4166 // optional int32 order = 1;
4167 if (cached_has_bits & 0x00000001u) {
4168 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
4169 }
4170
4171 // optional uint32 gfp_mask = 2;
4172 if (cached_has_bits & 0x00000002u) {
4173 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gfp_mask());
4174 }
4175
4176 // optional uint32 mode = 3;
4177 if (cached_has_bits & 0x00000004u) {
4178 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_mode());
4179 }
4180
4181 // optional int32 prio = 4;
4182 if (cached_has_bits & 0x00000008u) {
4183 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
4184 }
4185
4186 }
4187 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4188 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4189 }
4190 int cached_size = ::_pbi::ToCachedSize(total_size);
4191 SetCachedSize(cached_size);
4192 return total_size;
4193 }
4194
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4195 void MmCompactionTryToCompactPagesFtraceEvent::CheckTypeAndMergeFrom(
4196 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4197 MergeFrom(*::_pbi::DownCast<const MmCompactionTryToCompactPagesFtraceEvent*>(
4198 &from));
4199 }
4200
MergeFrom(const MmCompactionTryToCompactPagesFtraceEvent & from)4201 void MmCompactionTryToCompactPagesFtraceEvent::MergeFrom(const MmCompactionTryToCompactPagesFtraceEvent& from) {
4202 MmCompactionTryToCompactPagesFtraceEvent* const _this = this;
4203 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4204 GOOGLE_DCHECK_NE(&from, _this);
4205 ::uint32_t cached_has_bits = 0;
4206 (void) cached_has_bits;
4207
4208 cached_has_bits = from._impl_._has_bits_[0];
4209 if (cached_has_bits & 0x0000000fu) {
4210 if (cached_has_bits & 0x00000001u) {
4211 _this->_impl_.order_ = from._impl_.order_;
4212 }
4213 if (cached_has_bits & 0x00000002u) {
4214 _this->_impl_.gfp_mask_ = from._impl_.gfp_mask_;
4215 }
4216 if (cached_has_bits & 0x00000004u) {
4217 _this->_impl_.mode_ = from._impl_.mode_;
4218 }
4219 if (cached_has_bits & 0x00000008u) {
4220 _this->_impl_.prio_ = from._impl_.prio_;
4221 }
4222 _this->_impl_._has_bits_[0] |= cached_has_bits;
4223 }
4224 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4225 }
4226
CopyFrom(const MmCompactionTryToCompactPagesFtraceEvent & from)4227 void MmCompactionTryToCompactPagesFtraceEvent::CopyFrom(const MmCompactionTryToCompactPagesFtraceEvent& from) {
4228 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent)
4229 if (&from == this) return;
4230 Clear();
4231 MergeFrom(from);
4232 }
4233
IsInitialized() const4234 bool MmCompactionTryToCompactPagesFtraceEvent::IsInitialized() const {
4235 return true;
4236 }
4237
InternalSwap(MmCompactionTryToCompactPagesFtraceEvent * other)4238 void MmCompactionTryToCompactPagesFtraceEvent::InternalSwap(MmCompactionTryToCompactPagesFtraceEvent* other) {
4239 using std::swap;
4240 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4241 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4242 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4243 PROTOBUF_FIELD_OFFSET(MmCompactionTryToCompactPagesFtraceEvent, _impl_.prio_)
4244 + sizeof(MmCompactionTryToCompactPagesFtraceEvent::_impl_.prio_) // NOLINT
4245 - PROTOBUF_FIELD_OFFSET(MmCompactionTryToCompactPagesFtraceEvent, _impl_.order_)>(
4246 reinterpret_cast<char*>(&_impl_.order_),
4247 reinterpret_cast<char*>(&other->_impl_.order_));
4248 }
4249
GetTypeName() const4250 std::string MmCompactionTryToCompactPagesFtraceEvent::GetTypeName() const {
4251 return "perfetto.protos.MmCompactionTryToCompactPagesFtraceEvent";
4252 }
4253
4254
4255 // ===================================================================
4256
4257 class MmCompactionWakeupKcompactdFtraceEvent::_Internal {
4258 public:
4259 using HasBits = decltype(std::declval<MmCompactionWakeupKcompactdFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)4260 static void set_has_nid(HasBits* has_bits) {
4261 (*has_bits)[0] |= 1u;
4262 }
set_has_order(HasBits * has_bits)4263 static void set_has_order(HasBits* has_bits) {
4264 (*has_bits)[0] |= 2u;
4265 }
set_has_classzone_idx(HasBits * has_bits)4266 static void set_has_classzone_idx(HasBits* has_bits) {
4267 (*has_bits)[0] |= 4u;
4268 }
set_has_highest_zoneidx(HasBits * has_bits)4269 static void set_has_highest_zoneidx(HasBits* has_bits) {
4270 (*has_bits)[0] |= 8u;
4271 }
4272 };
4273
MmCompactionWakeupKcompactdFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)4274 MmCompactionWakeupKcompactdFtraceEvent::MmCompactionWakeupKcompactdFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
4275 bool is_message_owned)
4276 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
4277 SharedCtor(arena, is_message_owned);
4278 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4279 }
MmCompactionWakeupKcompactdFtraceEvent(const MmCompactionWakeupKcompactdFtraceEvent & from)4280 MmCompactionWakeupKcompactdFtraceEvent::MmCompactionWakeupKcompactdFtraceEvent(const MmCompactionWakeupKcompactdFtraceEvent& from)
4281 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
4282 MmCompactionWakeupKcompactdFtraceEvent* const _this = this; (void)_this;
4283 new (&_impl_) Impl_{
4284 decltype(_impl_._has_bits_){from._impl_._has_bits_}
4285 , /*decltype(_impl_._cached_size_)*/{}
4286 , decltype(_impl_.nid_){}
4287 , decltype(_impl_.order_){}
4288 , decltype(_impl_.classzone_idx_){}
4289 , decltype(_impl_.highest_zoneidx_){}};
4290
4291 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4292 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
4293 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.highest_zoneidx_) -
4294 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.highest_zoneidx_));
4295 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4296 }
4297
SharedCtor(::_pb::Arena * arena,bool is_message_owned)4298 inline void MmCompactionWakeupKcompactdFtraceEvent::SharedCtor(
4299 ::_pb::Arena* arena, bool is_message_owned) {
4300 (void)arena;
4301 (void)is_message_owned;
4302 new (&_impl_) Impl_{
4303 decltype(_impl_._has_bits_){}
4304 , /*decltype(_impl_._cached_size_)*/{}
4305 , decltype(_impl_.nid_){0}
4306 , decltype(_impl_.order_){0}
4307 , decltype(_impl_.classzone_idx_){0u}
4308 , decltype(_impl_.highest_zoneidx_){0u}
4309 };
4310 }
4311
~MmCompactionWakeupKcompactdFtraceEvent()4312 MmCompactionWakeupKcompactdFtraceEvent::~MmCompactionWakeupKcompactdFtraceEvent() {
4313 // @@protoc_insertion_point(destructor:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4314 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
4315 (void)arena;
4316 return;
4317 }
4318 SharedDtor();
4319 }
4320
SharedDtor()4321 inline void MmCompactionWakeupKcompactdFtraceEvent::SharedDtor() {
4322 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
4323 }
4324
SetCachedSize(int size) const4325 void MmCompactionWakeupKcompactdFtraceEvent::SetCachedSize(int size) const {
4326 _impl_._cached_size_.Set(size);
4327 }
4328
Clear()4329 void MmCompactionWakeupKcompactdFtraceEvent::Clear() {
4330 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4331 ::uint32_t cached_has_bits = 0;
4332 // Prevent compiler warnings about cached_has_bits being unused
4333 (void) cached_has_bits;
4334
4335 cached_has_bits = _impl_._has_bits_[0];
4336 if (cached_has_bits & 0x0000000fu) {
4337 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
4338 reinterpret_cast<char*>(&_impl_.highest_zoneidx_) -
4339 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.highest_zoneidx_));
4340 }
4341 _impl_._has_bits_.Clear();
4342 _internal_metadata_.Clear<std::string>();
4343 }
4344
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)4345 const char* MmCompactionWakeupKcompactdFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
4346 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
4347 _Internal::HasBits has_bits{};
4348 while (!ctx->Done(&ptr)) {
4349 ::uint32_t tag;
4350 ptr = ::_pbi::ReadTag(ptr, &tag);
4351 switch (tag >> 3) {
4352 // optional int32 nid = 1;
4353 case 1:
4354 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
4355 _Internal::set_has_nid(&has_bits);
4356 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4357 CHK_(ptr);
4358 } else {
4359 goto handle_unusual;
4360 }
4361 continue;
4362 // optional int32 order = 2;
4363 case 2:
4364 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
4365 _Internal::set_has_order(&has_bits);
4366 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4367 CHK_(ptr);
4368 } else {
4369 goto handle_unusual;
4370 }
4371 continue;
4372 // optional uint32 classzone_idx = 3;
4373 case 3:
4374 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
4375 _Internal::set_has_classzone_idx(&has_bits);
4376 _impl_.classzone_idx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4377 CHK_(ptr);
4378 } else {
4379 goto handle_unusual;
4380 }
4381 continue;
4382 // optional uint32 highest_zoneidx = 4;
4383 case 4:
4384 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
4385 _Internal::set_has_highest_zoneidx(&has_bits);
4386 _impl_.highest_zoneidx_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
4387 CHK_(ptr);
4388 } else {
4389 goto handle_unusual;
4390 }
4391 continue;
4392 default:
4393 goto handle_unusual;
4394 } // switch
4395 handle_unusual:
4396 if ((tag == 0) || ((tag & 7) == 4)) {
4397 CHK_(ptr);
4398 ctx->SetLastTag(tag);
4399 goto message_done;
4400 }
4401 ptr = UnknownFieldParse(
4402 tag,
4403 _internal_metadata_.mutable_unknown_fields<std::string>(),
4404 ptr, ctx);
4405 CHK_(ptr != nullptr);
4406 } // while
4407 message_done:
4408 _impl_._has_bits_.Or(has_bits);
4409 return ptr;
4410 failure:
4411 ptr = nullptr;
4412 goto message_done;
4413 #undef CHK_
4414 }
4415
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const4416 ::uint8_t* MmCompactionWakeupKcompactdFtraceEvent::_InternalSerialize(
4417 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
4418 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4419 ::uint32_t cached_has_bits = 0;
4420 (void) cached_has_bits;
4421
4422 cached_has_bits = _impl_._has_bits_[0];
4423 // optional int32 nid = 1;
4424 if (cached_has_bits & 0x00000001u) {
4425 target = stream->EnsureSpace(target);
4426 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
4427 }
4428
4429 // optional int32 order = 2;
4430 if (cached_has_bits & 0x00000002u) {
4431 target = stream->EnsureSpace(target);
4432 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_order(), target);
4433 }
4434
4435 // optional uint32 classzone_idx = 3;
4436 if (cached_has_bits & 0x00000004u) {
4437 target = stream->EnsureSpace(target);
4438 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_classzone_idx(), target);
4439 }
4440
4441 // optional uint32 highest_zoneidx = 4;
4442 if (cached_has_bits & 0x00000008u) {
4443 target = stream->EnsureSpace(target);
4444 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_highest_zoneidx(), target);
4445 }
4446
4447 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4448 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
4449 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
4450 }
4451 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4452 return target;
4453 }
4454
ByteSizeLong() const4455 size_t MmCompactionWakeupKcompactdFtraceEvent::ByteSizeLong() const {
4456 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4457 size_t total_size = 0;
4458
4459 ::uint32_t cached_has_bits = 0;
4460 // Prevent compiler warnings about cached_has_bits being unused
4461 (void) cached_has_bits;
4462
4463 cached_has_bits = _impl_._has_bits_[0];
4464 if (cached_has_bits & 0x0000000fu) {
4465 // optional int32 nid = 1;
4466 if (cached_has_bits & 0x00000001u) {
4467 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
4468 }
4469
4470 // optional int32 order = 2;
4471 if (cached_has_bits & 0x00000002u) {
4472 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
4473 }
4474
4475 // optional uint32 classzone_idx = 3;
4476 if (cached_has_bits & 0x00000004u) {
4477 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_classzone_idx());
4478 }
4479
4480 // optional uint32 highest_zoneidx = 4;
4481 if (cached_has_bits & 0x00000008u) {
4482 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_highest_zoneidx());
4483 }
4484
4485 }
4486 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
4487 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
4488 }
4489 int cached_size = ::_pbi::ToCachedSize(total_size);
4490 SetCachedSize(cached_size);
4491 return total_size;
4492 }
4493
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)4494 void MmCompactionWakeupKcompactdFtraceEvent::CheckTypeAndMergeFrom(
4495 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
4496 MergeFrom(*::_pbi::DownCast<const MmCompactionWakeupKcompactdFtraceEvent*>(
4497 &from));
4498 }
4499
MergeFrom(const MmCompactionWakeupKcompactdFtraceEvent & from)4500 void MmCompactionWakeupKcompactdFtraceEvent::MergeFrom(const MmCompactionWakeupKcompactdFtraceEvent& from) {
4501 MmCompactionWakeupKcompactdFtraceEvent* const _this = this;
4502 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4503 GOOGLE_DCHECK_NE(&from, _this);
4504 ::uint32_t cached_has_bits = 0;
4505 (void) cached_has_bits;
4506
4507 cached_has_bits = from._impl_._has_bits_[0];
4508 if (cached_has_bits & 0x0000000fu) {
4509 if (cached_has_bits & 0x00000001u) {
4510 _this->_impl_.nid_ = from._impl_.nid_;
4511 }
4512 if (cached_has_bits & 0x00000002u) {
4513 _this->_impl_.order_ = from._impl_.order_;
4514 }
4515 if (cached_has_bits & 0x00000004u) {
4516 _this->_impl_.classzone_idx_ = from._impl_.classzone_idx_;
4517 }
4518 if (cached_has_bits & 0x00000008u) {
4519 _this->_impl_.highest_zoneidx_ = from._impl_.highest_zoneidx_;
4520 }
4521 _this->_impl_._has_bits_[0] |= cached_has_bits;
4522 }
4523 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
4524 }
4525
CopyFrom(const MmCompactionWakeupKcompactdFtraceEvent & from)4526 void MmCompactionWakeupKcompactdFtraceEvent::CopyFrom(const MmCompactionWakeupKcompactdFtraceEvent& from) {
4527 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent)
4528 if (&from == this) return;
4529 Clear();
4530 MergeFrom(from);
4531 }
4532
IsInitialized() const4533 bool MmCompactionWakeupKcompactdFtraceEvent::IsInitialized() const {
4534 return true;
4535 }
4536
InternalSwap(MmCompactionWakeupKcompactdFtraceEvent * other)4537 void MmCompactionWakeupKcompactdFtraceEvent::InternalSwap(MmCompactionWakeupKcompactdFtraceEvent* other) {
4538 using std::swap;
4539 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
4540 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
4541 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
4542 PROTOBUF_FIELD_OFFSET(MmCompactionWakeupKcompactdFtraceEvent, _impl_.highest_zoneidx_)
4543 + sizeof(MmCompactionWakeupKcompactdFtraceEvent::_impl_.highest_zoneidx_) // NOLINT
4544 - PROTOBUF_FIELD_OFFSET(MmCompactionWakeupKcompactdFtraceEvent, _impl_.nid_)>(
4545 reinterpret_cast<char*>(&_impl_.nid_),
4546 reinterpret_cast<char*>(&other->_impl_.nid_));
4547 }
4548
GetTypeName() const4549 std::string MmCompactionWakeupKcompactdFtraceEvent::GetTypeName() const {
4550 return "perfetto.protos.MmCompactionWakeupKcompactdFtraceEvent";
4551 }
4552
4553
4554 // @@protoc_insertion_point(namespace_scope)
4555 } // namespace protos
4556 } // namespace perfetto
4557 PROTOBUF_NAMESPACE_OPEN
4558 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionBeginFtraceEvent*
CreateMaybeMessage(Arena * arena)4559 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionBeginFtraceEvent >(Arena* arena) {
4560 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionBeginFtraceEvent >(arena);
4561 }
4562 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionDeferCompactionFtraceEvent*
CreateMaybeMessage(Arena * arena)4563 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionDeferCompactionFtraceEvent >(Arena* arena) {
4564 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionDeferCompactionFtraceEvent >(arena);
4565 }
4566 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionDeferredFtraceEvent*
CreateMaybeMessage(Arena * arena)4567 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionDeferredFtraceEvent >(Arena* arena) {
4568 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionDeferredFtraceEvent >(arena);
4569 }
4570 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionDeferResetFtraceEvent*
CreateMaybeMessage(Arena * arena)4571 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionDeferResetFtraceEvent >(Arena* arena) {
4572 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionDeferResetFtraceEvent >(arena);
4573 }
4574 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionEndFtraceEvent*
CreateMaybeMessage(Arena * arena)4575 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionEndFtraceEvent >(Arena* arena) {
4576 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionEndFtraceEvent >(arena);
4577 }
4578 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionFinishedFtraceEvent*
CreateMaybeMessage(Arena * arena)4579 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionFinishedFtraceEvent >(Arena* arena) {
4580 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionFinishedFtraceEvent >(arena);
4581 }
4582 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionIsolateFreepagesFtraceEvent*
CreateMaybeMessage(Arena * arena)4583 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionIsolateFreepagesFtraceEvent >(Arena* arena) {
4584 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionIsolateFreepagesFtraceEvent >(arena);
4585 }
4586 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionIsolateMigratepagesFtraceEvent*
CreateMaybeMessage(Arena * arena)4587 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionIsolateMigratepagesFtraceEvent >(Arena* arena) {
4588 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionIsolateMigratepagesFtraceEvent >(arena);
4589 }
4590 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionKcompactdSleepFtraceEvent*
CreateMaybeMessage(Arena * arena)4591 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionKcompactdSleepFtraceEvent >(Arena* arena) {
4592 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionKcompactdSleepFtraceEvent >(arena);
4593 }
4594 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionKcompactdWakeFtraceEvent*
CreateMaybeMessage(Arena * arena)4595 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionKcompactdWakeFtraceEvent >(Arena* arena) {
4596 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionKcompactdWakeFtraceEvent >(arena);
4597 }
4598 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionMigratepagesFtraceEvent*
CreateMaybeMessage(Arena * arena)4599 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionMigratepagesFtraceEvent >(Arena* arena) {
4600 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionMigratepagesFtraceEvent >(arena);
4601 }
4602 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionSuitableFtraceEvent*
CreateMaybeMessage(Arena * arena)4603 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionSuitableFtraceEvent >(Arena* arena) {
4604 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionSuitableFtraceEvent >(arena);
4605 }
4606 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionTryToCompactPagesFtraceEvent*
CreateMaybeMessage(Arena * arena)4607 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionTryToCompactPagesFtraceEvent >(Arena* arena) {
4608 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionTryToCompactPagesFtraceEvent >(arena);
4609 }
4610 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmCompactionWakeupKcompactdFtraceEvent*
CreateMaybeMessage(Arena * arena)4611 Arena::CreateMaybeMessage< ::perfetto::protos::MmCompactionWakeupKcompactdFtraceEvent >(Arena* arena) {
4612 return Arena::CreateMessageInternal< ::perfetto::protos::MmCompactionWakeupKcompactdFtraceEvent >(arena);
4613 }
4614 PROTOBUF_NAMESPACE_CLOSE
4615
4616 // @@protoc_insertion_point(global_scope)
4617 #include <google/protobuf/port_undef.inc>
4618