1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/cgroup.proto
3
4 #include "protos/perfetto/trace/ftrace/cgroup.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 {
CgroupAttachTaskFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR CgroupAttachTaskFtraceEvent::CgroupAttachTaskFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28 , /*decltype(_impl_.cname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29 , /*decltype(_impl_.dst_path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
30 , /*decltype(_impl_.dst_root_)*/0
31 , /*decltype(_impl_.dst_id_)*/0
32 , /*decltype(_impl_.pid_)*/0
33 , /*decltype(_impl_.dst_level_)*/0} {}
34 struct CgroupAttachTaskFtraceEventDefaultTypeInternal {
CgroupAttachTaskFtraceEventDefaultTypeInternalperfetto::protos::CgroupAttachTaskFtraceEventDefaultTypeInternal35 PROTOBUF_CONSTEXPR CgroupAttachTaskFtraceEventDefaultTypeInternal()
36 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupAttachTaskFtraceEventDefaultTypeInternalperfetto::protos::CgroupAttachTaskFtraceEventDefaultTypeInternal37 ~CgroupAttachTaskFtraceEventDefaultTypeInternal() {}
38 union { // NOLINT(misc-non-private-member-variables-in-classes)
39 CgroupAttachTaskFtraceEvent _instance;
40 };
41 };
42 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupAttachTaskFtraceEventDefaultTypeInternal _CgroupAttachTaskFtraceEvent_default_instance_;
CgroupMkdirFtraceEvent(::_pbi::ConstantInitialized)43 PROTOBUF_CONSTEXPR CgroupMkdirFtraceEvent::CgroupMkdirFtraceEvent(
44 ::_pbi::ConstantInitialized): _impl_{
45 /*decltype(_impl_._has_bits_)*/{}
46 , /*decltype(_impl_._cached_size_)*/{}
47 , /*decltype(_impl_.cname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
48 , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
49 , /*decltype(_impl_.root_)*/0
50 , /*decltype(_impl_.id_)*/0
51 , /*decltype(_impl_.level_)*/0} {}
52 struct CgroupMkdirFtraceEventDefaultTypeInternal {
CgroupMkdirFtraceEventDefaultTypeInternalperfetto::protos::CgroupMkdirFtraceEventDefaultTypeInternal53 PROTOBUF_CONSTEXPR CgroupMkdirFtraceEventDefaultTypeInternal()
54 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupMkdirFtraceEventDefaultTypeInternalperfetto::protos::CgroupMkdirFtraceEventDefaultTypeInternal55 ~CgroupMkdirFtraceEventDefaultTypeInternal() {}
56 union { // NOLINT(misc-non-private-member-variables-in-classes)
57 CgroupMkdirFtraceEvent _instance;
58 };
59 };
60 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupMkdirFtraceEventDefaultTypeInternal _CgroupMkdirFtraceEvent_default_instance_;
CgroupRemountFtraceEvent(::_pbi::ConstantInitialized)61 PROTOBUF_CONSTEXPR CgroupRemountFtraceEvent::CgroupRemountFtraceEvent(
62 ::_pbi::ConstantInitialized): _impl_{
63 /*decltype(_impl_._has_bits_)*/{}
64 , /*decltype(_impl_._cached_size_)*/{}
65 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
66 , /*decltype(_impl_.root_)*/0
67 , /*decltype(_impl_.ss_mask_)*/0u} {}
68 struct CgroupRemountFtraceEventDefaultTypeInternal {
CgroupRemountFtraceEventDefaultTypeInternalperfetto::protos::CgroupRemountFtraceEventDefaultTypeInternal69 PROTOBUF_CONSTEXPR CgroupRemountFtraceEventDefaultTypeInternal()
70 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupRemountFtraceEventDefaultTypeInternalperfetto::protos::CgroupRemountFtraceEventDefaultTypeInternal71 ~CgroupRemountFtraceEventDefaultTypeInternal() {}
72 union { // NOLINT(misc-non-private-member-variables-in-classes)
73 CgroupRemountFtraceEvent _instance;
74 };
75 };
76 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupRemountFtraceEventDefaultTypeInternal _CgroupRemountFtraceEvent_default_instance_;
CgroupRmdirFtraceEvent(::_pbi::ConstantInitialized)77 PROTOBUF_CONSTEXPR CgroupRmdirFtraceEvent::CgroupRmdirFtraceEvent(
78 ::_pbi::ConstantInitialized): _impl_{
79 /*decltype(_impl_._has_bits_)*/{}
80 , /*decltype(_impl_._cached_size_)*/{}
81 , /*decltype(_impl_.cname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
82 , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
83 , /*decltype(_impl_.root_)*/0
84 , /*decltype(_impl_.id_)*/0
85 , /*decltype(_impl_.level_)*/0} {}
86 struct CgroupRmdirFtraceEventDefaultTypeInternal {
CgroupRmdirFtraceEventDefaultTypeInternalperfetto::protos::CgroupRmdirFtraceEventDefaultTypeInternal87 PROTOBUF_CONSTEXPR CgroupRmdirFtraceEventDefaultTypeInternal()
88 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupRmdirFtraceEventDefaultTypeInternalperfetto::protos::CgroupRmdirFtraceEventDefaultTypeInternal89 ~CgroupRmdirFtraceEventDefaultTypeInternal() {}
90 union { // NOLINT(misc-non-private-member-variables-in-classes)
91 CgroupRmdirFtraceEvent _instance;
92 };
93 };
94 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupRmdirFtraceEventDefaultTypeInternal _CgroupRmdirFtraceEvent_default_instance_;
CgroupTransferTasksFtraceEvent(::_pbi::ConstantInitialized)95 PROTOBUF_CONSTEXPR CgroupTransferTasksFtraceEvent::CgroupTransferTasksFtraceEvent(
96 ::_pbi::ConstantInitialized): _impl_{
97 /*decltype(_impl_._has_bits_)*/{}
98 , /*decltype(_impl_._cached_size_)*/{}
99 , /*decltype(_impl_.comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
100 , /*decltype(_impl_.cname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
101 , /*decltype(_impl_.dst_path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
102 , /*decltype(_impl_.dst_root_)*/0
103 , /*decltype(_impl_.dst_id_)*/0
104 , /*decltype(_impl_.pid_)*/0
105 , /*decltype(_impl_.dst_level_)*/0} {}
106 struct CgroupTransferTasksFtraceEventDefaultTypeInternal {
CgroupTransferTasksFtraceEventDefaultTypeInternalperfetto::protos::CgroupTransferTasksFtraceEventDefaultTypeInternal107 PROTOBUF_CONSTEXPR CgroupTransferTasksFtraceEventDefaultTypeInternal()
108 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupTransferTasksFtraceEventDefaultTypeInternalperfetto::protos::CgroupTransferTasksFtraceEventDefaultTypeInternal109 ~CgroupTransferTasksFtraceEventDefaultTypeInternal() {}
110 union { // NOLINT(misc-non-private-member-variables-in-classes)
111 CgroupTransferTasksFtraceEvent _instance;
112 };
113 };
114 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupTransferTasksFtraceEventDefaultTypeInternal _CgroupTransferTasksFtraceEvent_default_instance_;
CgroupDestroyRootFtraceEvent(::_pbi::ConstantInitialized)115 PROTOBUF_CONSTEXPR CgroupDestroyRootFtraceEvent::CgroupDestroyRootFtraceEvent(
116 ::_pbi::ConstantInitialized): _impl_{
117 /*decltype(_impl_._has_bits_)*/{}
118 , /*decltype(_impl_._cached_size_)*/{}
119 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
120 , /*decltype(_impl_.root_)*/0
121 , /*decltype(_impl_.ss_mask_)*/0u} {}
122 struct CgroupDestroyRootFtraceEventDefaultTypeInternal {
CgroupDestroyRootFtraceEventDefaultTypeInternalperfetto::protos::CgroupDestroyRootFtraceEventDefaultTypeInternal123 PROTOBUF_CONSTEXPR CgroupDestroyRootFtraceEventDefaultTypeInternal()
124 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupDestroyRootFtraceEventDefaultTypeInternalperfetto::protos::CgroupDestroyRootFtraceEventDefaultTypeInternal125 ~CgroupDestroyRootFtraceEventDefaultTypeInternal() {}
126 union { // NOLINT(misc-non-private-member-variables-in-classes)
127 CgroupDestroyRootFtraceEvent _instance;
128 };
129 };
130 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupDestroyRootFtraceEventDefaultTypeInternal _CgroupDestroyRootFtraceEvent_default_instance_;
CgroupReleaseFtraceEvent(::_pbi::ConstantInitialized)131 PROTOBUF_CONSTEXPR CgroupReleaseFtraceEvent::CgroupReleaseFtraceEvent(
132 ::_pbi::ConstantInitialized): _impl_{
133 /*decltype(_impl_._has_bits_)*/{}
134 , /*decltype(_impl_._cached_size_)*/{}
135 , /*decltype(_impl_.cname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
136 , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
137 , /*decltype(_impl_.root_)*/0
138 , /*decltype(_impl_.id_)*/0
139 , /*decltype(_impl_.level_)*/0} {}
140 struct CgroupReleaseFtraceEventDefaultTypeInternal {
CgroupReleaseFtraceEventDefaultTypeInternalperfetto::protos::CgroupReleaseFtraceEventDefaultTypeInternal141 PROTOBUF_CONSTEXPR CgroupReleaseFtraceEventDefaultTypeInternal()
142 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupReleaseFtraceEventDefaultTypeInternalperfetto::protos::CgroupReleaseFtraceEventDefaultTypeInternal143 ~CgroupReleaseFtraceEventDefaultTypeInternal() {}
144 union { // NOLINT(misc-non-private-member-variables-in-classes)
145 CgroupReleaseFtraceEvent _instance;
146 };
147 };
148 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupReleaseFtraceEventDefaultTypeInternal _CgroupReleaseFtraceEvent_default_instance_;
CgroupRenameFtraceEvent(::_pbi::ConstantInitialized)149 PROTOBUF_CONSTEXPR CgroupRenameFtraceEvent::CgroupRenameFtraceEvent(
150 ::_pbi::ConstantInitialized): _impl_{
151 /*decltype(_impl_._has_bits_)*/{}
152 , /*decltype(_impl_._cached_size_)*/{}
153 , /*decltype(_impl_.cname_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
154 , /*decltype(_impl_.path_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
155 , /*decltype(_impl_.root_)*/0
156 , /*decltype(_impl_.id_)*/0
157 , /*decltype(_impl_.level_)*/0} {}
158 struct CgroupRenameFtraceEventDefaultTypeInternal {
CgroupRenameFtraceEventDefaultTypeInternalperfetto::protos::CgroupRenameFtraceEventDefaultTypeInternal159 PROTOBUF_CONSTEXPR CgroupRenameFtraceEventDefaultTypeInternal()
160 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupRenameFtraceEventDefaultTypeInternalperfetto::protos::CgroupRenameFtraceEventDefaultTypeInternal161 ~CgroupRenameFtraceEventDefaultTypeInternal() {}
162 union { // NOLINT(misc-non-private-member-variables-in-classes)
163 CgroupRenameFtraceEvent _instance;
164 };
165 };
166 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupRenameFtraceEventDefaultTypeInternal _CgroupRenameFtraceEvent_default_instance_;
CgroupSetupRootFtraceEvent(::_pbi::ConstantInitialized)167 PROTOBUF_CONSTEXPR CgroupSetupRootFtraceEvent::CgroupSetupRootFtraceEvent(
168 ::_pbi::ConstantInitialized): _impl_{
169 /*decltype(_impl_._has_bits_)*/{}
170 , /*decltype(_impl_._cached_size_)*/{}
171 , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
172 , /*decltype(_impl_.root_)*/0
173 , /*decltype(_impl_.ss_mask_)*/0u} {}
174 struct CgroupSetupRootFtraceEventDefaultTypeInternal {
CgroupSetupRootFtraceEventDefaultTypeInternalperfetto::protos::CgroupSetupRootFtraceEventDefaultTypeInternal175 PROTOBUF_CONSTEXPR CgroupSetupRootFtraceEventDefaultTypeInternal()
176 : _instance(::_pbi::ConstantInitialized{}) {}
~CgroupSetupRootFtraceEventDefaultTypeInternalperfetto::protos::CgroupSetupRootFtraceEventDefaultTypeInternal177 ~CgroupSetupRootFtraceEventDefaultTypeInternal() {}
178 union { // NOLINT(misc-non-private-member-variables-in-classes)
179 CgroupSetupRootFtraceEvent _instance;
180 };
181 };
182 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CgroupSetupRootFtraceEventDefaultTypeInternal _CgroupSetupRootFtraceEvent_default_instance_;
183 } // namespace protos
184 } // namespace perfetto
185 namespace perfetto {
186 namespace protos {
187
188 // ===================================================================
189
190 class CgroupAttachTaskFtraceEvent::_Internal {
191 public:
192 using HasBits = decltype(std::declval<CgroupAttachTaskFtraceEvent>()._impl_._has_bits_);
set_has_dst_root(HasBits * has_bits)193 static void set_has_dst_root(HasBits* has_bits) {
194 (*has_bits)[0] |= 8u;
195 }
set_has_dst_id(HasBits * has_bits)196 static void set_has_dst_id(HasBits* has_bits) {
197 (*has_bits)[0] |= 16u;
198 }
set_has_pid(HasBits * has_bits)199 static void set_has_pid(HasBits* has_bits) {
200 (*has_bits)[0] |= 32u;
201 }
set_has_comm(HasBits * has_bits)202 static void set_has_comm(HasBits* has_bits) {
203 (*has_bits)[0] |= 1u;
204 }
set_has_cname(HasBits * has_bits)205 static void set_has_cname(HasBits* has_bits) {
206 (*has_bits)[0] |= 2u;
207 }
set_has_dst_level(HasBits * has_bits)208 static void set_has_dst_level(HasBits* has_bits) {
209 (*has_bits)[0] |= 64u;
210 }
set_has_dst_path(HasBits * has_bits)211 static void set_has_dst_path(HasBits* has_bits) {
212 (*has_bits)[0] |= 4u;
213 }
214 };
215
CgroupAttachTaskFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)216 CgroupAttachTaskFtraceEvent::CgroupAttachTaskFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
217 bool is_message_owned)
218 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
219 SharedCtor(arena, is_message_owned);
220 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupAttachTaskFtraceEvent)
221 }
CgroupAttachTaskFtraceEvent(const CgroupAttachTaskFtraceEvent & from)222 CgroupAttachTaskFtraceEvent::CgroupAttachTaskFtraceEvent(const CgroupAttachTaskFtraceEvent& from)
223 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
224 CgroupAttachTaskFtraceEvent* const _this = this; (void)_this;
225 new (&_impl_) Impl_{
226 decltype(_impl_._has_bits_){from._impl_._has_bits_}
227 , /*decltype(_impl_._cached_size_)*/{}
228 , decltype(_impl_.comm_){}
229 , decltype(_impl_.cname_){}
230 , decltype(_impl_.dst_path_){}
231 , decltype(_impl_.dst_root_){}
232 , decltype(_impl_.dst_id_){}
233 , decltype(_impl_.pid_){}
234 , decltype(_impl_.dst_level_){}};
235
236 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
237 _impl_.comm_.InitDefault();
238 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
239 _impl_.comm_.Set("", GetArenaForAllocation());
240 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
241 if (from._internal_has_comm()) {
242 _this->_impl_.comm_.Set(from._internal_comm(),
243 _this->GetArenaForAllocation());
244 }
245 _impl_.cname_.InitDefault();
246 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
247 _impl_.cname_.Set("", GetArenaForAllocation());
248 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
249 if (from._internal_has_cname()) {
250 _this->_impl_.cname_.Set(from._internal_cname(),
251 _this->GetArenaForAllocation());
252 }
253 _impl_.dst_path_.InitDefault();
254 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
255 _impl_.dst_path_.Set("", GetArenaForAllocation());
256 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
257 if (from._internal_has_dst_path()) {
258 _this->_impl_.dst_path_.Set(from._internal_dst_path(),
259 _this->GetArenaForAllocation());
260 }
261 ::memcpy(&_impl_.dst_root_, &from._impl_.dst_root_,
262 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dst_level_) -
263 reinterpret_cast<char*>(&_impl_.dst_root_)) + sizeof(_impl_.dst_level_));
264 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupAttachTaskFtraceEvent)
265 }
266
SharedCtor(::_pb::Arena * arena,bool is_message_owned)267 inline void CgroupAttachTaskFtraceEvent::SharedCtor(
268 ::_pb::Arena* arena, bool is_message_owned) {
269 (void)arena;
270 (void)is_message_owned;
271 new (&_impl_) Impl_{
272 decltype(_impl_._has_bits_){}
273 , /*decltype(_impl_._cached_size_)*/{}
274 , decltype(_impl_.comm_){}
275 , decltype(_impl_.cname_){}
276 , decltype(_impl_.dst_path_){}
277 , decltype(_impl_.dst_root_){0}
278 , decltype(_impl_.dst_id_){0}
279 , decltype(_impl_.pid_){0}
280 , decltype(_impl_.dst_level_){0}
281 };
282 _impl_.comm_.InitDefault();
283 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
284 _impl_.comm_.Set("", GetArenaForAllocation());
285 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
286 _impl_.cname_.InitDefault();
287 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
288 _impl_.cname_.Set("", GetArenaForAllocation());
289 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
290 _impl_.dst_path_.InitDefault();
291 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
292 _impl_.dst_path_.Set("", GetArenaForAllocation());
293 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
294 }
295
~CgroupAttachTaskFtraceEvent()296 CgroupAttachTaskFtraceEvent::~CgroupAttachTaskFtraceEvent() {
297 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupAttachTaskFtraceEvent)
298 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
299 (void)arena;
300 return;
301 }
302 SharedDtor();
303 }
304
SharedDtor()305 inline void CgroupAttachTaskFtraceEvent::SharedDtor() {
306 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
307 _impl_.comm_.Destroy();
308 _impl_.cname_.Destroy();
309 _impl_.dst_path_.Destroy();
310 }
311
SetCachedSize(int size) const312 void CgroupAttachTaskFtraceEvent::SetCachedSize(int size) const {
313 _impl_._cached_size_.Set(size);
314 }
315
Clear()316 void CgroupAttachTaskFtraceEvent::Clear() {
317 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupAttachTaskFtraceEvent)
318 ::uint32_t cached_has_bits = 0;
319 // Prevent compiler warnings about cached_has_bits being unused
320 (void) cached_has_bits;
321
322 cached_has_bits = _impl_._has_bits_[0];
323 if (cached_has_bits & 0x00000007u) {
324 if (cached_has_bits & 0x00000001u) {
325 _impl_.comm_.ClearNonDefaultToEmpty();
326 }
327 if (cached_has_bits & 0x00000002u) {
328 _impl_.cname_.ClearNonDefaultToEmpty();
329 }
330 if (cached_has_bits & 0x00000004u) {
331 _impl_.dst_path_.ClearNonDefaultToEmpty();
332 }
333 }
334 if (cached_has_bits & 0x00000078u) {
335 ::memset(&_impl_.dst_root_, 0, static_cast<size_t>(
336 reinterpret_cast<char*>(&_impl_.dst_level_) -
337 reinterpret_cast<char*>(&_impl_.dst_root_)) + sizeof(_impl_.dst_level_));
338 }
339 _impl_._has_bits_.Clear();
340 _internal_metadata_.Clear<std::string>();
341 }
342
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)343 const char* CgroupAttachTaskFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
344 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
345 _Internal::HasBits has_bits{};
346 while (!ctx->Done(&ptr)) {
347 ::uint32_t tag;
348 ptr = ::_pbi::ReadTag(ptr, &tag);
349 switch (tag >> 3) {
350 // optional int32 dst_root = 1;
351 case 1:
352 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
353 _Internal::set_has_dst_root(&has_bits);
354 _impl_.dst_root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
355 CHK_(ptr);
356 } else {
357 goto handle_unusual;
358 }
359 continue;
360 // optional int32 dst_id = 2;
361 case 2:
362 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
363 _Internal::set_has_dst_id(&has_bits);
364 _impl_.dst_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
365 CHK_(ptr);
366 } else {
367 goto handle_unusual;
368 }
369 continue;
370 // optional int32 pid = 3;
371 case 3:
372 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
373 _Internal::set_has_pid(&has_bits);
374 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
375 CHK_(ptr);
376 } else {
377 goto handle_unusual;
378 }
379 continue;
380 // optional string comm = 4;
381 case 4:
382 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
383 auto str = _internal_mutable_comm();
384 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
385 CHK_(ptr);
386 } else {
387 goto handle_unusual;
388 }
389 continue;
390 // optional string cname = 5;
391 case 5:
392 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
393 auto str = _internal_mutable_cname();
394 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
395 CHK_(ptr);
396 } else {
397 goto handle_unusual;
398 }
399 continue;
400 // optional int32 dst_level = 6;
401 case 6:
402 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
403 _Internal::set_has_dst_level(&has_bits);
404 _impl_.dst_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
405 CHK_(ptr);
406 } else {
407 goto handle_unusual;
408 }
409 continue;
410 // optional string dst_path = 7;
411 case 7:
412 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
413 auto str = _internal_mutable_dst_path();
414 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
415 CHK_(ptr);
416 } else {
417 goto handle_unusual;
418 }
419 continue;
420 default:
421 goto handle_unusual;
422 } // switch
423 handle_unusual:
424 if ((tag == 0) || ((tag & 7) == 4)) {
425 CHK_(ptr);
426 ctx->SetLastTag(tag);
427 goto message_done;
428 }
429 ptr = UnknownFieldParse(
430 tag,
431 _internal_metadata_.mutable_unknown_fields<std::string>(),
432 ptr, ctx);
433 CHK_(ptr != nullptr);
434 } // while
435 message_done:
436 _impl_._has_bits_.Or(has_bits);
437 return ptr;
438 failure:
439 ptr = nullptr;
440 goto message_done;
441 #undef CHK_
442 }
443
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const444 ::uint8_t* CgroupAttachTaskFtraceEvent::_InternalSerialize(
445 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
446 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupAttachTaskFtraceEvent)
447 ::uint32_t cached_has_bits = 0;
448 (void) cached_has_bits;
449
450 cached_has_bits = _impl_._has_bits_[0];
451 // optional int32 dst_root = 1;
452 if (cached_has_bits & 0x00000008u) {
453 target = stream->EnsureSpace(target);
454 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_dst_root(), target);
455 }
456
457 // optional int32 dst_id = 2;
458 if (cached_has_bits & 0x00000010u) {
459 target = stream->EnsureSpace(target);
460 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_dst_id(), target);
461 }
462
463 // optional int32 pid = 3;
464 if (cached_has_bits & 0x00000020u) {
465 target = stream->EnsureSpace(target);
466 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_pid(), target);
467 }
468
469 // optional string comm = 4;
470 if (cached_has_bits & 0x00000001u) {
471 target = stream->WriteStringMaybeAliased(
472 4, this->_internal_comm(), target);
473 }
474
475 // optional string cname = 5;
476 if (cached_has_bits & 0x00000002u) {
477 target = stream->WriteStringMaybeAliased(
478 5, this->_internal_cname(), target);
479 }
480
481 // optional int32 dst_level = 6;
482 if (cached_has_bits & 0x00000040u) {
483 target = stream->EnsureSpace(target);
484 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_dst_level(), target);
485 }
486
487 // optional string dst_path = 7;
488 if (cached_has_bits & 0x00000004u) {
489 target = stream->WriteStringMaybeAliased(
490 7, this->_internal_dst_path(), target);
491 }
492
493 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
494 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
495 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
496 }
497 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupAttachTaskFtraceEvent)
498 return target;
499 }
500
ByteSizeLong() const501 size_t CgroupAttachTaskFtraceEvent::ByteSizeLong() const {
502 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupAttachTaskFtraceEvent)
503 size_t total_size = 0;
504
505 ::uint32_t cached_has_bits = 0;
506 // Prevent compiler warnings about cached_has_bits being unused
507 (void) cached_has_bits;
508
509 cached_has_bits = _impl_._has_bits_[0];
510 if (cached_has_bits & 0x0000007fu) {
511 // optional string comm = 4;
512 if (cached_has_bits & 0x00000001u) {
513 total_size += 1 +
514 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
515 this->_internal_comm());
516 }
517
518 // optional string cname = 5;
519 if (cached_has_bits & 0x00000002u) {
520 total_size += 1 +
521 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
522 this->_internal_cname());
523 }
524
525 // optional string dst_path = 7;
526 if (cached_has_bits & 0x00000004u) {
527 total_size += 1 +
528 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
529 this->_internal_dst_path());
530 }
531
532 // optional int32 dst_root = 1;
533 if (cached_has_bits & 0x00000008u) {
534 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dst_root());
535 }
536
537 // optional int32 dst_id = 2;
538 if (cached_has_bits & 0x00000010u) {
539 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dst_id());
540 }
541
542 // optional int32 pid = 3;
543 if (cached_has_bits & 0x00000020u) {
544 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
545 }
546
547 // optional int32 dst_level = 6;
548 if (cached_has_bits & 0x00000040u) {
549 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dst_level());
550 }
551
552 }
553 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
554 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
555 }
556 int cached_size = ::_pbi::ToCachedSize(total_size);
557 SetCachedSize(cached_size);
558 return total_size;
559 }
560
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)561 void CgroupAttachTaskFtraceEvent::CheckTypeAndMergeFrom(
562 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
563 MergeFrom(*::_pbi::DownCast<const CgroupAttachTaskFtraceEvent*>(
564 &from));
565 }
566
MergeFrom(const CgroupAttachTaskFtraceEvent & from)567 void CgroupAttachTaskFtraceEvent::MergeFrom(const CgroupAttachTaskFtraceEvent& from) {
568 CgroupAttachTaskFtraceEvent* const _this = this;
569 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupAttachTaskFtraceEvent)
570 GOOGLE_DCHECK_NE(&from, _this);
571 ::uint32_t cached_has_bits = 0;
572 (void) cached_has_bits;
573
574 cached_has_bits = from._impl_._has_bits_[0];
575 if (cached_has_bits & 0x0000007fu) {
576 if (cached_has_bits & 0x00000001u) {
577 _this->_internal_set_comm(from._internal_comm());
578 }
579 if (cached_has_bits & 0x00000002u) {
580 _this->_internal_set_cname(from._internal_cname());
581 }
582 if (cached_has_bits & 0x00000004u) {
583 _this->_internal_set_dst_path(from._internal_dst_path());
584 }
585 if (cached_has_bits & 0x00000008u) {
586 _this->_impl_.dst_root_ = from._impl_.dst_root_;
587 }
588 if (cached_has_bits & 0x00000010u) {
589 _this->_impl_.dst_id_ = from._impl_.dst_id_;
590 }
591 if (cached_has_bits & 0x00000020u) {
592 _this->_impl_.pid_ = from._impl_.pid_;
593 }
594 if (cached_has_bits & 0x00000040u) {
595 _this->_impl_.dst_level_ = from._impl_.dst_level_;
596 }
597 _this->_impl_._has_bits_[0] |= cached_has_bits;
598 }
599 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
600 }
601
CopyFrom(const CgroupAttachTaskFtraceEvent & from)602 void CgroupAttachTaskFtraceEvent::CopyFrom(const CgroupAttachTaskFtraceEvent& from) {
603 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupAttachTaskFtraceEvent)
604 if (&from == this) return;
605 Clear();
606 MergeFrom(from);
607 }
608
IsInitialized() const609 bool CgroupAttachTaskFtraceEvent::IsInitialized() const {
610 return true;
611 }
612
InternalSwap(CgroupAttachTaskFtraceEvent * other)613 void CgroupAttachTaskFtraceEvent::InternalSwap(CgroupAttachTaskFtraceEvent* other) {
614 using std::swap;
615 auto* lhs_arena = GetArenaForAllocation();
616 auto* rhs_arena = other->GetArenaForAllocation();
617 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
618 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
619 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
620 &_impl_.comm_, lhs_arena,
621 &other->_impl_.comm_, rhs_arena
622 );
623 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
624 &_impl_.cname_, lhs_arena,
625 &other->_impl_.cname_, rhs_arena
626 );
627 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
628 &_impl_.dst_path_, lhs_arena,
629 &other->_impl_.dst_path_, rhs_arena
630 );
631 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
632 PROTOBUF_FIELD_OFFSET(CgroupAttachTaskFtraceEvent, _impl_.dst_level_)
633 + sizeof(CgroupAttachTaskFtraceEvent::_impl_.dst_level_) // NOLINT
634 - PROTOBUF_FIELD_OFFSET(CgroupAttachTaskFtraceEvent, _impl_.dst_root_)>(
635 reinterpret_cast<char*>(&_impl_.dst_root_),
636 reinterpret_cast<char*>(&other->_impl_.dst_root_));
637 }
638
GetTypeName() const639 std::string CgroupAttachTaskFtraceEvent::GetTypeName() const {
640 return "perfetto.protos.CgroupAttachTaskFtraceEvent";
641 }
642
643
644 // ===================================================================
645
646 class CgroupMkdirFtraceEvent::_Internal {
647 public:
648 using HasBits = decltype(std::declval<CgroupMkdirFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)649 static void set_has_root(HasBits* has_bits) {
650 (*has_bits)[0] |= 4u;
651 }
set_has_id(HasBits * has_bits)652 static void set_has_id(HasBits* has_bits) {
653 (*has_bits)[0] |= 8u;
654 }
set_has_cname(HasBits * has_bits)655 static void set_has_cname(HasBits* has_bits) {
656 (*has_bits)[0] |= 1u;
657 }
set_has_level(HasBits * has_bits)658 static void set_has_level(HasBits* has_bits) {
659 (*has_bits)[0] |= 16u;
660 }
set_has_path(HasBits * has_bits)661 static void set_has_path(HasBits* has_bits) {
662 (*has_bits)[0] |= 2u;
663 }
664 };
665
CgroupMkdirFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)666 CgroupMkdirFtraceEvent::CgroupMkdirFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
667 bool is_message_owned)
668 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
669 SharedCtor(arena, is_message_owned);
670 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupMkdirFtraceEvent)
671 }
CgroupMkdirFtraceEvent(const CgroupMkdirFtraceEvent & from)672 CgroupMkdirFtraceEvent::CgroupMkdirFtraceEvent(const CgroupMkdirFtraceEvent& from)
673 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
674 CgroupMkdirFtraceEvent* const _this = this; (void)_this;
675 new (&_impl_) Impl_{
676 decltype(_impl_._has_bits_){from._impl_._has_bits_}
677 , /*decltype(_impl_._cached_size_)*/{}
678 , decltype(_impl_.cname_){}
679 , decltype(_impl_.path_){}
680 , decltype(_impl_.root_){}
681 , decltype(_impl_.id_){}
682 , decltype(_impl_.level_){}};
683
684 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
685 _impl_.cname_.InitDefault();
686 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
687 _impl_.cname_.Set("", GetArenaForAllocation());
688 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
689 if (from._internal_has_cname()) {
690 _this->_impl_.cname_.Set(from._internal_cname(),
691 _this->GetArenaForAllocation());
692 }
693 _impl_.path_.InitDefault();
694 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
695 _impl_.path_.Set("", GetArenaForAllocation());
696 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
697 if (from._internal_has_path()) {
698 _this->_impl_.path_.Set(from._internal_path(),
699 _this->GetArenaForAllocation());
700 }
701 ::memcpy(&_impl_.root_, &from._impl_.root_,
702 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.level_) -
703 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
704 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupMkdirFtraceEvent)
705 }
706
SharedCtor(::_pb::Arena * arena,bool is_message_owned)707 inline void CgroupMkdirFtraceEvent::SharedCtor(
708 ::_pb::Arena* arena, bool is_message_owned) {
709 (void)arena;
710 (void)is_message_owned;
711 new (&_impl_) Impl_{
712 decltype(_impl_._has_bits_){}
713 , /*decltype(_impl_._cached_size_)*/{}
714 , decltype(_impl_.cname_){}
715 , decltype(_impl_.path_){}
716 , decltype(_impl_.root_){0}
717 , decltype(_impl_.id_){0}
718 , decltype(_impl_.level_){0}
719 };
720 _impl_.cname_.InitDefault();
721 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
722 _impl_.cname_.Set("", GetArenaForAllocation());
723 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
724 _impl_.path_.InitDefault();
725 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
726 _impl_.path_.Set("", GetArenaForAllocation());
727 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
728 }
729
~CgroupMkdirFtraceEvent()730 CgroupMkdirFtraceEvent::~CgroupMkdirFtraceEvent() {
731 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupMkdirFtraceEvent)
732 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
733 (void)arena;
734 return;
735 }
736 SharedDtor();
737 }
738
SharedDtor()739 inline void CgroupMkdirFtraceEvent::SharedDtor() {
740 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
741 _impl_.cname_.Destroy();
742 _impl_.path_.Destroy();
743 }
744
SetCachedSize(int size) const745 void CgroupMkdirFtraceEvent::SetCachedSize(int size) const {
746 _impl_._cached_size_.Set(size);
747 }
748
Clear()749 void CgroupMkdirFtraceEvent::Clear() {
750 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupMkdirFtraceEvent)
751 ::uint32_t cached_has_bits = 0;
752 // Prevent compiler warnings about cached_has_bits being unused
753 (void) cached_has_bits;
754
755 cached_has_bits = _impl_._has_bits_[0];
756 if (cached_has_bits & 0x00000003u) {
757 if (cached_has_bits & 0x00000001u) {
758 _impl_.cname_.ClearNonDefaultToEmpty();
759 }
760 if (cached_has_bits & 0x00000002u) {
761 _impl_.path_.ClearNonDefaultToEmpty();
762 }
763 }
764 if (cached_has_bits & 0x0000001cu) {
765 ::memset(&_impl_.root_, 0, static_cast<size_t>(
766 reinterpret_cast<char*>(&_impl_.level_) -
767 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
768 }
769 _impl_._has_bits_.Clear();
770 _internal_metadata_.Clear<std::string>();
771 }
772
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)773 const char* CgroupMkdirFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
774 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
775 _Internal::HasBits has_bits{};
776 while (!ctx->Done(&ptr)) {
777 ::uint32_t tag;
778 ptr = ::_pbi::ReadTag(ptr, &tag);
779 switch (tag >> 3) {
780 // optional int32 root = 1;
781 case 1:
782 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
783 _Internal::set_has_root(&has_bits);
784 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
785 CHK_(ptr);
786 } else {
787 goto handle_unusual;
788 }
789 continue;
790 // optional int32 id = 2;
791 case 2:
792 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
793 _Internal::set_has_id(&has_bits);
794 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
795 CHK_(ptr);
796 } else {
797 goto handle_unusual;
798 }
799 continue;
800 // optional string cname = 3;
801 case 3:
802 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
803 auto str = _internal_mutable_cname();
804 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
805 CHK_(ptr);
806 } else {
807 goto handle_unusual;
808 }
809 continue;
810 // optional int32 level = 4;
811 case 4:
812 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
813 _Internal::set_has_level(&has_bits);
814 _impl_.level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
815 CHK_(ptr);
816 } else {
817 goto handle_unusual;
818 }
819 continue;
820 // optional string path = 5;
821 case 5:
822 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
823 auto str = _internal_mutable_path();
824 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
825 CHK_(ptr);
826 } else {
827 goto handle_unusual;
828 }
829 continue;
830 default:
831 goto handle_unusual;
832 } // switch
833 handle_unusual:
834 if ((tag == 0) || ((tag & 7) == 4)) {
835 CHK_(ptr);
836 ctx->SetLastTag(tag);
837 goto message_done;
838 }
839 ptr = UnknownFieldParse(
840 tag,
841 _internal_metadata_.mutable_unknown_fields<std::string>(),
842 ptr, ctx);
843 CHK_(ptr != nullptr);
844 } // while
845 message_done:
846 _impl_._has_bits_.Or(has_bits);
847 return ptr;
848 failure:
849 ptr = nullptr;
850 goto message_done;
851 #undef CHK_
852 }
853
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const854 ::uint8_t* CgroupMkdirFtraceEvent::_InternalSerialize(
855 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
856 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupMkdirFtraceEvent)
857 ::uint32_t cached_has_bits = 0;
858 (void) cached_has_bits;
859
860 cached_has_bits = _impl_._has_bits_[0];
861 // optional int32 root = 1;
862 if (cached_has_bits & 0x00000004u) {
863 target = stream->EnsureSpace(target);
864 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
865 }
866
867 // optional int32 id = 2;
868 if (cached_has_bits & 0x00000008u) {
869 target = stream->EnsureSpace(target);
870 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_id(), target);
871 }
872
873 // optional string cname = 3;
874 if (cached_has_bits & 0x00000001u) {
875 target = stream->WriteStringMaybeAliased(
876 3, this->_internal_cname(), target);
877 }
878
879 // optional int32 level = 4;
880 if (cached_has_bits & 0x00000010u) {
881 target = stream->EnsureSpace(target);
882 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_level(), target);
883 }
884
885 // optional string path = 5;
886 if (cached_has_bits & 0x00000002u) {
887 target = stream->WriteStringMaybeAliased(
888 5, this->_internal_path(), target);
889 }
890
891 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
892 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
893 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
894 }
895 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupMkdirFtraceEvent)
896 return target;
897 }
898
ByteSizeLong() const899 size_t CgroupMkdirFtraceEvent::ByteSizeLong() const {
900 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupMkdirFtraceEvent)
901 size_t total_size = 0;
902
903 ::uint32_t cached_has_bits = 0;
904 // Prevent compiler warnings about cached_has_bits being unused
905 (void) cached_has_bits;
906
907 cached_has_bits = _impl_._has_bits_[0];
908 if (cached_has_bits & 0x0000001fu) {
909 // optional string cname = 3;
910 if (cached_has_bits & 0x00000001u) {
911 total_size += 1 +
912 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
913 this->_internal_cname());
914 }
915
916 // optional string path = 5;
917 if (cached_has_bits & 0x00000002u) {
918 total_size += 1 +
919 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
920 this->_internal_path());
921 }
922
923 // optional int32 root = 1;
924 if (cached_has_bits & 0x00000004u) {
925 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
926 }
927
928 // optional int32 id = 2;
929 if (cached_has_bits & 0x00000008u) {
930 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
931 }
932
933 // optional int32 level = 4;
934 if (cached_has_bits & 0x00000010u) {
935 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_level());
936 }
937
938 }
939 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
940 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
941 }
942 int cached_size = ::_pbi::ToCachedSize(total_size);
943 SetCachedSize(cached_size);
944 return total_size;
945 }
946
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)947 void CgroupMkdirFtraceEvent::CheckTypeAndMergeFrom(
948 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
949 MergeFrom(*::_pbi::DownCast<const CgroupMkdirFtraceEvent*>(
950 &from));
951 }
952
MergeFrom(const CgroupMkdirFtraceEvent & from)953 void CgroupMkdirFtraceEvent::MergeFrom(const CgroupMkdirFtraceEvent& from) {
954 CgroupMkdirFtraceEvent* const _this = this;
955 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupMkdirFtraceEvent)
956 GOOGLE_DCHECK_NE(&from, _this);
957 ::uint32_t cached_has_bits = 0;
958 (void) cached_has_bits;
959
960 cached_has_bits = from._impl_._has_bits_[0];
961 if (cached_has_bits & 0x0000001fu) {
962 if (cached_has_bits & 0x00000001u) {
963 _this->_internal_set_cname(from._internal_cname());
964 }
965 if (cached_has_bits & 0x00000002u) {
966 _this->_internal_set_path(from._internal_path());
967 }
968 if (cached_has_bits & 0x00000004u) {
969 _this->_impl_.root_ = from._impl_.root_;
970 }
971 if (cached_has_bits & 0x00000008u) {
972 _this->_impl_.id_ = from._impl_.id_;
973 }
974 if (cached_has_bits & 0x00000010u) {
975 _this->_impl_.level_ = from._impl_.level_;
976 }
977 _this->_impl_._has_bits_[0] |= cached_has_bits;
978 }
979 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
980 }
981
CopyFrom(const CgroupMkdirFtraceEvent & from)982 void CgroupMkdirFtraceEvent::CopyFrom(const CgroupMkdirFtraceEvent& from) {
983 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupMkdirFtraceEvent)
984 if (&from == this) return;
985 Clear();
986 MergeFrom(from);
987 }
988
IsInitialized() const989 bool CgroupMkdirFtraceEvent::IsInitialized() const {
990 return true;
991 }
992
InternalSwap(CgroupMkdirFtraceEvent * other)993 void CgroupMkdirFtraceEvent::InternalSwap(CgroupMkdirFtraceEvent* other) {
994 using std::swap;
995 auto* lhs_arena = GetArenaForAllocation();
996 auto* rhs_arena = other->GetArenaForAllocation();
997 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
998 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
999 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1000 &_impl_.cname_, lhs_arena,
1001 &other->_impl_.cname_, rhs_arena
1002 );
1003 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1004 &_impl_.path_, lhs_arena,
1005 &other->_impl_.path_, rhs_arena
1006 );
1007 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1008 PROTOBUF_FIELD_OFFSET(CgroupMkdirFtraceEvent, _impl_.level_)
1009 + sizeof(CgroupMkdirFtraceEvent::_impl_.level_) // NOLINT
1010 - PROTOBUF_FIELD_OFFSET(CgroupMkdirFtraceEvent, _impl_.root_)>(
1011 reinterpret_cast<char*>(&_impl_.root_),
1012 reinterpret_cast<char*>(&other->_impl_.root_));
1013 }
1014
GetTypeName() const1015 std::string CgroupMkdirFtraceEvent::GetTypeName() const {
1016 return "perfetto.protos.CgroupMkdirFtraceEvent";
1017 }
1018
1019
1020 // ===================================================================
1021
1022 class CgroupRemountFtraceEvent::_Internal {
1023 public:
1024 using HasBits = decltype(std::declval<CgroupRemountFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)1025 static void set_has_root(HasBits* has_bits) {
1026 (*has_bits)[0] |= 2u;
1027 }
set_has_ss_mask(HasBits * has_bits)1028 static void set_has_ss_mask(HasBits* has_bits) {
1029 (*has_bits)[0] |= 4u;
1030 }
set_has_name(HasBits * has_bits)1031 static void set_has_name(HasBits* has_bits) {
1032 (*has_bits)[0] |= 1u;
1033 }
1034 };
1035
CgroupRemountFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1036 CgroupRemountFtraceEvent::CgroupRemountFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1037 bool is_message_owned)
1038 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1039 SharedCtor(arena, is_message_owned);
1040 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupRemountFtraceEvent)
1041 }
CgroupRemountFtraceEvent(const CgroupRemountFtraceEvent & from)1042 CgroupRemountFtraceEvent::CgroupRemountFtraceEvent(const CgroupRemountFtraceEvent& from)
1043 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1044 CgroupRemountFtraceEvent* const _this = this; (void)_this;
1045 new (&_impl_) Impl_{
1046 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1047 , /*decltype(_impl_._cached_size_)*/{}
1048 , decltype(_impl_.name_){}
1049 , decltype(_impl_.root_){}
1050 , decltype(_impl_.ss_mask_){}};
1051
1052 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1053 _impl_.name_.InitDefault();
1054 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1055 _impl_.name_.Set("", GetArenaForAllocation());
1056 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1057 if (from._internal_has_name()) {
1058 _this->_impl_.name_.Set(from._internal_name(),
1059 _this->GetArenaForAllocation());
1060 }
1061 ::memcpy(&_impl_.root_, &from._impl_.root_,
1062 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ss_mask_) -
1063 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.ss_mask_));
1064 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupRemountFtraceEvent)
1065 }
1066
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1067 inline void CgroupRemountFtraceEvent::SharedCtor(
1068 ::_pb::Arena* arena, bool is_message_owned) {
1069 (void)arena;
1070 (void)is_message_owned;
1071 new (&_impl_) Impl_{
1072 decltype(_impl_._has_bits_){}
1073 , /*decltype(_impl_._cached_size_)*/{}
1074 , decltype(_impl_.name_){}
1075 , decltype(_impl_.root_){0}
1076 , decltype(_impl_.ss_mask_){0u}
1077 };
1078 _impl_.name_.InitDefault();
1079 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1080 _impl_.name_.Set("", GetArenaForAllocation());
1081 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1082 }
1083
~CgroupRemountFtraceEvent()1084 CgroupRemountFtraceEvent::~CgroupRemountFtraceEvent() {
1085 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupRemountFtraceEvent)
1086 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1087 (void)arena;
1088 return;
1089 }
1090 SharedDtor();
1091 }
1092
SharedDtor()1093 inline void CgroupRemountFtraceEvent::SharedDtor() {
1094 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1095 _impl_.name_.Destroy();
1096 }
1097
SetCachedSize(int size) const1098 void CgroupRemountFtraceEvent::SetCachedSize(int size) const {
1099 _impl_._cached_size_.Set(size);
1100 }
1101
Clear()1102 void CgroupRemountFtraceEvent::Clear() {
1103 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupRemountFtraceEvent)
1104 ::uint32_t cached_has_bits = 0;
1105 // Prevent compiler warnings about cached_has_bits being unused
1106 (void) cached_has_bits;
1107
1108 cached_has_bits = _impl_._has_bits_[0];
1109 if (cached_has_bits & 0x00000001u) {
1110 _impl_.name_.ClearNonDefaultToEmpty();
1111 }
1112 if (cached_has_bits & 0x00000006u) {
1113 ::memset(&_impl_.root_, 0, static_cast<size_t>(
1114 reinterpret_cast<char*>(&_impl_.ss_mask_) -
1115 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.ss_mask_));
1116 }
1117 _impl_._has_bits_.Clear();
1118 _internal_metadata_.Clear<std::string>();
1119 }
1120
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1121 const char* CgroupRemountFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1122 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1123 _Internal::HasBits has_bits{};
1124 while (!ctx->Done(&ptr)) {
1125 ::uint32_t tag;
1126 ptr = ::_pbi::ReadTag(ptr, &tag);
1127 switch (tag >> 3) {
1128 // optional int32 root = 1;
1129 case 1:
1130 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1131 _Internal::set_has_root(&has_bits);
1132 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1133 CHK_(ptr);
1134 } else {
1135 goto handle_unusual;
1136 }
1137 continue;
1138 // optional uint32 ss_mask = 2;
1139 case 2:
1140 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1141 _Internal::set_has_ss_mask(&has_bits);
1142 _impl_.ss_mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1143 CHK_(ptr);
1144 } else {
1145 goto handle_unusual;
1146 }
1147 continue;
1148 // optional string name = 3;
1149 case 3:
1150 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1151 auto str = _internal_mutable_name();
1152 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1153 CHK_(ptr);
1154 } else {
1155 goto handle_unusual;
1156 }
1157 continue;
1158 default:
1159 goto handle_unusual;
1160 } // switch
1161 handle_unusual:
1162 if ((tag == 0) || ((tag & 7) == 4)) {
1163 CHK_(ptr);
1164 ctx->SetLastTag(tag);
1165 goto message_done;
1166 }
1167 ptr = UnknownFieldParse(
1168 tag,
1169 _internal_metadata_.mutable_unknown_fields<std::string>(),
1170 ptr, ctx);
1171 CHK_(ptr != nullptr);
1172 } // while
1173 message_done:
1174 _impl_._has_bits_.Or(has_bits);
1175 return ptr;
1176 failure:
1177 ptr = nullptr;
1178 goto message_done;
1179 #undef CHK_
1180 }
1181
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1182 ::uint8_t* CgroupRemountFtraceEvent::_InternalSerialize(
1183 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1184 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupRemountFtraceEvent)
1185 ::uint32_t cached_has_bits = 0;
1186 (void) cached_has_bits;
1187
1188 cached_has_bits = _impl_._has_bits_[0];
1189 // optional int32 root = 1;
1190 if (cached_has_bits & 0x00000002u) {
1191 target = stream->EnsureSpace(target);
1192 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
1193 }
1194
1195 // optional uint32 ss_mask = 2;
1196 if (cached_has_bits & 0x00000004u) {
1197 target = stream->EnsureSpace(target);
1198 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ss_mask(), target);
1199 }
1200
1201 // optional string name = 3;
1202 if (cached_has_bits & 0x00000001u) {
1203 target = stream->WriteStringMaybeAliased(
1204 3, this->_internal_name(), target);
1205 }
1206
1207 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1208 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1209 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1210 }
1211 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupRemountFtraceEvent)
1212 return target;
1213 }
1214
ByteSizeLong() const1215 size_t CgroupRemountFtraceEvent::ByteSizeLong() const {
1216 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupRemountFtraceEvent)
1217 size_t total_size = 0;
1218
1219 ::uint32_t cached_has_bits = 0;
1220 // Prevent compiler warnings about cached_has_bits being unused
1221 (void) cached_has_bits;
1222
1223 cached_has_bits = _impl_._has_bits_[0];
1224 if (cached_has_bits & 0x00000007u) {
1225 // optional string name = 3;
1226 if (cached_has_bits & 0x00000001u) {
1227 total_size += 1 +
1228 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1229 this->_internal_name());
1230 }
1231
1232 // optional int32 root = 1;
1233 if (cached_has_bits & 0x00000002u) {
1234 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
1235 }
1236
1237 // optional uint32 ss_mask = 2;
1238 if (cached_has_bits & 0x00000004u) {
1239 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ss_mask());
1240 }
1241
1242 }
1243 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1244 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1245 }
1246 int cached_size = ::_pbi::ToCachedSize(total_size);
1247 SetCachedSize(cached_size);
1248 return total_size;
1249 }
1250
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1251 void CgroupRemountFtraceEvent::CheckTypeAndMergeFrom(
1252 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1253 MergeFrom(*::_pbi::DownCast<const CgroupRemountFtraceEvent*>(
1254 &from));
1255 }
1256
MergeFrom(const CgroupRemountFtraceEvent & from)1257 void CgroupRemountFtraceEvent::MergeFrom(const CgroupRemountFtraceEvent& from) {
1258 CgroupRemountFtraceEvent* const _this = this;
1259 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupRemountFtraceEvent)
1260 GOOGLE_DCHECK_NE(&from, _this);
1261 ::uint32_t cached_has_bits = 0;
1262 (void) cached_has_bits;
1263
1264 cached_has_bits = from._impl_._has_bits_[0];
1265 if (cached_has_bits & 0x00000007u) {
1266 if (cached_has_bits & 0x00000001u) {
1267 _this->_internal_set_name(from._internal_name());
1268 }
1269 if (cached_has_bits & 0x00000002u) {
1270 _this->_impl_.root_ = from._impl_.root_;
1271 }
1272 if (cached_has_bits & 0x00000004u) {
1273 _this->_impl_.ss_mask_ = from._impl_.ss_mask_;
1274 }
1275 _this->_impl_._has_bits_[0] |= cached_has_bits;
1276 }
1277 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1278 }
1279
CopyFrom(const CgroupRemountFtraceEvent & from)1280 void CgroupRemountFtraceEvent::CopyFrom(const CgroupRemountFtraceEvent& from) {
1281 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupRemountFtraceEvent)
1282 if (&from == this) return;
1283 Clear();
1284 MergeFrom(from);
1285 }
1286
IsInitialized() const1287 bool CgroupRemountFtraceEvent::IsInitialized() const {
1288 return true;
1289 }
1290
InternalSwap(CgroupRemountFtraceEvent * other)1291 void CgroupRemountFtraceEvent::InternalSwap(CgroupRemountFtraceEvent* other) {
1292 using std::swap;
1293 auto* lhs_arena = GetArenaForAllocation();
1294 auto* rhs_arena = other->GetArenaForAllocation();
1295 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1296 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1297 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1298 &_impl_.name_, lhs_arena,
1299 &other->_impl_.name_, rhs_arena
1300 );
1301 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1302 PROTOBUF_FIELD_OFFSET(CgroupRemountFtraceEvent, _impl_.ss_mask_)
1303 + sizeof(CgroupRemountFtraceEvent::_impl_.ss_mask_) // NOLINT
1304 - PROTOBUF_FIELD_OFFSET(CgroupRemountFtraceEvent, _impl_.root_)>(
1305 reinterpret_cast<char*>(&_impl_.root_),
1306 reinterpret_cast<char*>(&other->_impl_.root_));
1307 }
1308
GetTypeName() const1309 std::string CgroupRemountFtraceEvent::GetTypeName() const {
1310 return "perfetto.protos.CgroupRemountFtraceEvent";
1311 }
1312
1313
1314 // ===================================================================
1315
1316 class CgroupRmdirFtraceEvent::_Internal {
1317 public:
1318 using HasBits = decltype(std::declval<CgroupRmdirFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)1319 static void set_has_root(HasBits* has_bits) {
1320 (*has_bits)[0] |= 4u;
1321 }
set_has_id(HasBits * has_bits)1322 static void set_has_id(HasBits* has_bits) {
1323 (*has_bits)[0] |= 8u;
1324 }
set_has_cname(HasBits * has_bits)1325 static void set_has_cname(HasBits* has_bits) {
1326 (*has_bits)[0] |= 1u;
1327 }
set_has_level(HasBits * has_bits)1328 static void set_has_level(HasBits* has_bits) {
1329 (*has_bits)[0] |= 16u;
1330 }
set_has_path(HasBits * has_bits)1331 static void set_has_path(HasBits* has_bits) {
1332 (*has_bits)[0] |= 2u;
1333 }
1334 };
1335
CgroupRmdirFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1336 CgroupRmdirFtraceEvent::CgroupRmdirFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1337 bool is_message_owned)
1338 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1339 SharedCtor(arena, is_message_owned);
1340 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupRmdirFtraceEvent)
1341 }
CgroupRmdirFtraceEvent(const CgroupRmdirFtraceEvent & from)1342 CgroupRmdirFtraceEvent::CgroupRmdirFtraceEvent(const CgroupRmdirFtraceEvent& from)
1343 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1344 CgroupRmdirFtraceEvent* const _this = this; (void)_this;
1345 new (&_impl_) Impl_{
1346 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1347 , /*decltype(_impl_._cached_size_)*/{}
1348 , decltype(_impl_.cname_){}
1349 , decltype(_impl_.path_){}
1350 , decltype(_impl_.root_){}
1351 , decltype(_impl_.id_){}
1352 , decltype(_impl_.level_){}};
1353
1354 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1355 _impl_.cname_.InitDefault();
1356 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1357 _impl_.cname_.Set("", GetArenaForAllocation());
1358 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1359 if (from._internal_has_cname()) {
1360 _this->_impl_.cname_.Set(from._internal_cname(),
1361 _this->GetArenaForAllocation());
1362 }
1363 _impl_.path_.InitDefault();
1364 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1365 _impl_.path_.Set("", GetArenaForAllocation());
1366 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1367 if (from._internal_has_path()) {
1368 _this->_impl_.path_.Set(from._internal_path(),
1369 _this->GetArenaForAllocation());
1370 }
1371 ::memcpy(&_impl_.root_, &from._impl_.root_,
1372 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.level_) -
1373 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
1374 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupRmdirFtraceEvent)
1375 }
1376
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1377 inline void CgroupRmdirFtraceEvent::SharedCtor(
1378 ::_pb::Arena* arena, bool is_message_owned) {
1379 (void)arena;
1380 (void)is_message_owned;
1381 new (&_impl_) Impl_{
1382 decltype(_impl_._has_bits_){}
1383 , /*decltype(_impl_._cached_size_)*/{}
1384 , decltype(_impl_.cname_){}
1385 , decltype(_impl_.path_){}
1386 , decltype(_impl_.root_){0}
1387 , decltype(_impl_.id_){0}
1388 , decltype(_impl_.level_){0}
1389 };
1390 _impl_.cname_.InitDefault();
1391 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1392 _impl_.cname_.Set("", GetArenaForAllocation());
1393 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1394 _impl_.path_.InitDefault();
1395 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1396 _impl_.path_.Set("", GetArenaForAllocation());
1397 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1398 }
1399
~CgroupRmdirFtraceEvent()1400 CgroupRmdirFtraceEvent::~CgroupRmdirFtraceEvent() {
1401 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupRmdirFtraceEvent)
1402 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1403 (void)arena;
1404 return;
1405 }
1406 SharedDtor();
1407 }
1408
SharedDtor()1409 inline void CgroupRmdirFtraceEvent::SharedDtor() {
1410 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1411 _impl_.cname_.Destroy();
1412 _impl_.path_.Destroy();
1413 }
1414
SetCachedSize(int size) const1415 void CgroupRmdirFtraceEvent::SetCachedSize(int size) const {
1416 _impl_._cached_size_.Set(size);
1417 }
1418
Clear()1419 void CgroupRmdirFtraceEvent::Clear() {
1420 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupRmdirFtraceEvent)
1421 ::uint32_t cached_has_bits = 0;
1422 // Prevent compiler warnings about cached_has_bits being unused
1423 (void) cached_has_bits;
1424
1425 cached_has_bits = _impl_._has_bits_[0];
1426 if (cached_has_bits & 0x00000003u) {
1427 if (cached_has_bits & 0x00000001u) {
1428 _impl_.cname_.ClearNonDefaultToEmpty();
1429 }
1430 if (cached_has_bits & 0x00000002u) {
1431 _impl_.path_.ClearNonDefaultToEmpty();
1432 }
1433 }
1434 if (cached_has_bits & 0x0000001cu) {
1435 ::memset(&_impl_.root_, 0, static_cast<size_t>(
1436 reinterpret_cast<char*>(&_impl_.level_) -
1437 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
1438 }
1439 _impl_._has_bits_.Clear();
1440 _internal_metadata_.Clear<std::string>();
1441 }
1442
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1443 const char* CgroupRmdirFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1444 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1445 _Internal::HasBits has_bits{};
1446 while (!ctx->Done(&ptr)) {
1447 ::uint32_t tag;
1448 ptr = ::_pbi::ReadTag(ptr, &tag);
1449 switch (tag >> 3) {
1450 // optional int32 root = 1;
1451 case 1:
1452 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1453 _Internal::set_has_root(&has_bits);
1454 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1455 CHK_(ptr);
1456 } else {
1457 goto handle_unusual;
1458 }
1459 continue;
1460 // optional int32 id = 2;
1461 case 2:
1462 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1463 _Internal::set_has_id(&has_bits);
1464 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1465 CHK_(ptr);
1466 } else {
1467 goto handle_unusual;
1468 }
1469 continue;
1470 // optional string cname = 3;
1471 case 3:
1472 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1473 auto str = _internal_mutable_cname();
1474 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1475 CHK_(ptr);
1476 } else {
1477 goto handle_unusual;
1478 }
1479 continue;
1480 // optional int32 level = 4;
1481 case 4:
1482 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1483 _Internal::set_has_level(&has_bits);
1484 _impl_.level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1485 CHK_(ptr);
1486 } else {
1487 goto handle_unusual;
1488 }
1489 continue;
1490 // optional string path = 5;
1491 case 5:
1492 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1493 auto str = _internal_mutable_path();
1494 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1495 CHK_(ptr);
1496 } else {
1497 goto handle_unusual;
1498 }
1499 continue;
1500 default:
1501 goto handle_unusual;
1502 } // switch
1503 handle_unusual:
1504 if ((tag == 0) || ((tag & 7) == 4)) {
1505 CHK_(ptr);
1506 ctx->SetLastTag(tag);
1507 goto message_done;
1508 }
1509 ptr = UnknownFieldParse(
1510 tag,
1511 _internal_metadata_.mutable_unknown_fields<std::string>(),
1512 ptr, ctx);
1513 CHK_(ptr != nullptr);
1514 } // while
1515 message_done:
1516 _impl_._has_bits_.Or(has_bits);
1517 return ptr;
1518 failure:
1519 ptr = nullptr;
1520 goto message_done;
1521 #undef CHK_
1522 }
1523
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1524 ::uint8_t* CgroupRmdirFtraceEvent::_InternalSerialize(
1525 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1526 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupRmdirFtraceEvent)
1527 ::uint32_t cached_has_bits = 0;
1528 (void) cached_has_bits;
1529
1530 cached_has_bits = _impl_._has_bits_[0];
1531 // optional int32 root = 1;
1532 if (cached_has_bits & 0x00000004u) {
1533 target = stream->EnsureSpace(target);
1534 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
1535 }
1536
1537 // optional int32 id = 2;
1538 if (cached_has_bits & 0x00000008u) {
1539 target = stream->EnsureSpace(target);
1540 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_id(), target);
1541 }
1542
1543 // optional string cname = 3;
1544 if (cached_has_bits & 0x00000001u) {
1545 target = stream->WriteStringMaybeAliased(
1546 3, this->_internal_cname(), target);
1547 }
1548
1549 // optional int32 level = 4;
1550 if (cached_has_bits & 0x00000010u) {
1551 target = stream->EnsureSpace(target);
1552 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_level(), target);
1553 }
1554
1555 // optional string path = 5;
1556 if (cached_has_bits & 0x00000002u) {
1557 target = stream->WriteStringMaybeAliased(
1558 5, this->_internal_path(), target);
1559 }
1560
1561 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1562 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1563 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1564 }
1565 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupRmdirFtraceEvent)
1566 return target;
1567 }
1568
ByteSizeLong() const1569 size_t CgroupRmdirFtraceEvent::ByteSizeLong() const {
1570 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupRmdirFtraceEvent)
1571 size_t total_size = 0;
1572
1573 ::uint32_t cached_has_bits = 0;
1574 // Prevent compiler warnings about cached_has_bits being unused
1575 (void) cached_has_bits;
1576
1577 cached_has_bits = _impl_._has_bits_[0];
1578 if (cached_has_bits & 0x0000001fu) {
1579 // optional string cname = 3;
1580 if (cached_has_bits & 0x00000001u) {
1581 total_size += 1 +
1582 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1583 this->_internal_cname());
1584 }
1585
1586 // optional string path = 5;
1587 if (cached_has_bits & 0x00000002u) {
1588 total_size += 1 +
1589 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1590 this->_internal_path());
1591 }
1592
1593 // optional int32 root = 1;
1594 if (cached_has_bits & 0x00000004u) {
1595 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
1596 }
1597
1598 // optional int32 id = 2;
1599 if (cached_has_bits & 0x00000008u) {
1600 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
1601 }
1602
1603 // optional int32 level = 4;
1604 if (cached_has_bits & 0x00000010u) {
1605 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_level());
1606 }
1607
1608 }
1609 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1610 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1611 }
1612 int cached_size = ::_pbi::ToCachedSize(total_size);
1613 SetCachedSize(cached_size);
1614 return total_size;
1615 }
1616
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1617 void CgroupRmdirFtraceEvent::CheckTypeAndMergeFrom(
1618 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1619 MergeFrom(*::_pbi::DownCast<const CgroupRmdirFtraceEvent*>(
1620 &from));
1621 }
1622
MergeFrom(const CgroupRmdirFtraceEvent & from)1623 void CgroupRmdirFtraceEvent::MergeFrom(const CgroupRmdirFtraceEvent& from) {
1624 CgroupRmdirFtraceEvent* const _this = this;
1625 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupRmdirFtraceEvent)
1626 GOOGLE_DCHECK_NE(&from, _this);
1627 ::uint32_t cached_has_bits = 0;
1628 (void) cached_has_bits;
1629
1630 cached_has_bits = from._impl_._has_bits_[0];
1631 if (cached_has_bits & 0x0000001fu) {
1632 if (cached_has_bits & 0x00000001u) {
1633 _this->_internal_set_cname(from._internal_cname());
1634 }
1635 if (cached_has_bits & 0x00000002u) {
1636 _this->_internal_set_path(from._internal_path());
1637 }
1638 if (cached_has_bits & 0x00000004u) {
1639 _this->_impl_.root_ = from._impl_.root_;
1640 }
1641 if (cached_has_bits & 0x00000008u) {
1642 _this->_impl_.id_ = from._impl_.id_;
1643 }
1644 if (cached_has_bits & 0x00000010u) {
1645 _this->_impl_.level_ = from._impl_.level_;
1646 }
1647 _this->_impl_._has_bits_[0] |= cached_has_bits;
1648 }
1649 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1650 }
1651
CopyFrom(const CgroupRmdirFtraceEvent & from)1652 void CgroupRmdirFtraceEvent::CopyFrom(const CgroupRmdirFtraceEvent& from) {
1653 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupRmdirFtraceEvent)
1654 if (&from == this) return;
1655 Clear();
1656 MergeFrom(from);
1657 }
1658
IsInitialized() const1659 bool CgroupRmdirFtraceEvent::IsInitialized() const {
1660 return true;
1661 }
1662
InternalSwap(CgroupRmdirFtraceEvent * other)1663 void CgroupRmdirFtraceEvent::InternalSwap(CgroupRmdirFtraceEvent* other) {
1664 using std::swap;
1665 auto* lhs_arena = GetArenaForAllocation();
1666 auto* rhs_arena = other->GetArenaForAllocation();
1667 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1668 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1669 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1670 &_impl_.cname_, lhs_arena,
1671 &other->_impl_.cname_, rhs_arena
1672 );
1673 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1674 &_impl_.path_, lhs_arena,
1675 &other->_impl_.path_, rhs_arena
1676 );
1677 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1678 PROTOBUF_FIELD_OFFSET(CgroupRmdirFtraceEvent, _impl_.level_)
1679 + sizeof(CgroupRmdirFtraceEvent::_impl_.level_) // NOLINT
1680 - PROTOBUF_FIELD_OFFSET(CgroupRmdirFtraceEvent, _impl_.root_)>(
1681 reinterpret_cast<char*>(&_impl_.root_),
1682 reinterpret_cast<char*>(&other->_impl_.root_));
1683 }
1684
GetTypeName() const1685 std::string CgroupRmdirFtraceEvent::GetTypeName() const {
1686 return "perfetto.protos.CgroupRmdirFtraceEvent";
1687 }
1688
1689
1690 // ===================================================================
1691
1692 class CgroupTransferTasksFtraceEvent::_Internal {
1693 public:
1694 using HasBits = decltype(std::declval<CgroupTransferTasksFtraceEvent>()._impl_._has_bits_);
set_has_dst_root(HasBits * has_bits)1695 static void set_has_dst_root(HasBits* has_bits) {
1696 (*has_bits)[0] |= 8u;
1697 }
set_has_dst_id(HasBits * has_bits)1698 static void set_has_dst_id(HasBits* has_bits) {
1699 (*has_bits)[0] |= 16u;
1700 }
set_has_pid(HasBits * has_bits)1701 static void set_has_pid(HasBits* has_bits) {
1702 (*has_bits)[0] |= 32u;
1703 }
set_has_comm(HasBits * has_bits)1704 static void set_has_comm(HasBits* has_bits) {
1705 (*has_bits)[0] |= 1u;
1706 }
set_has_cname(HasBits * has_bits)1707 static void set_has_cname(HasBits* has_bits) {
1708 (*has_bits)[0] |= 2u;
1709 }
set_has_dst_level(HasBits * has_bits)1710 static void set_has_dst_level(HasBits* has_bits) {
1711 (*has_bits)[0] |= 64u;
1712 }
set_has_dst_path(HasBits * has_bits)1713 static void set_has_dst_path(HasBits* has_bits) {
1714 (*has_bits)[0] |= 4u;
1715 }
1716 };
1717
CgroupTransferTasksFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1718 CgroupTransferTasksFtraceEvent::CgroupTransferTasksFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1719 bool is_message_owned)
1720 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1721 SharedCtor(arena, is_message_owned);
1722 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupTransferTasksFtraceEvent)
1723 }
CgroupTransferTasksFtraceEvent(const CgroupTransferTasksFtraceEvent & from)1724 CgroupTransferTasksFtraceEvent::CgroupTransferTasksFtraceEvent(const CgroupTransferTasksFtraceEvent& from)
1725 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1726 CgroupTransferTasksFtraceEvent* const _this = this; (void)_this;
1727 new (&_impl_) Impl_{
1728 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1729 , /*decltype(_impl_._cached_size_)*/{}
1730 , decltype(_impl_.comm_){}
1731 , decltype(_impl_.cname_){}
1732 , decltype(_impl_.dst_path_){}
1733 , decltype(_impl_.dst_root_){}
1734 , decltype(_impl_.dst_id_){}
1735 , decltype(_impl_.pid_){}
1736 , decltype(_impl_.dst_level_){}};
1737
1738 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1739 _impl_.comm_.InitDefault();
1740 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1741 _impl_.comm_.Set("", GetArenaForAllocation());
1742 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1743 if (from._internal_has_comm()) {
1744 _this->_impl_.comm_.Set(from._internal_comm(),
1745 _this->GetArenaForAllocation());
1746 }
1747 _impl_.cname_.InitDefault();
1748 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1749 _impl_.cname_.Set("", GetArenaForAllocation());
1750 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1751 if (from._internal_has_cname()) {
1752 _this->_impl_.cname_.Set(from._internal_cname(),
1753 _this->GetArenaForAllocation());
1754 }
1755 _impl_.dst_path_.InitDefault();
1756 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1757 _impl_.dst_path_.Set("", GetArenaForAllocation());
1758 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1759 if (from._internal_has_dst_path()) {
1760 _this->_impl_.dst_path_.Set(from._internal_dst_path(),
1761 _this->GetArenaForAllocation());
1762 }
1763 ::memcpy(&_impl_.dst_root_, &from._impl_.dst_root_,
1764 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dst_level_) -
1765 reinterpret_cast<char*>(&_impl_.dst_root_)) + sizeof(_impl_.dst_level_));
1766 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupTransferTasksFtraceEvent)
1767 }
1768
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1769 inline void CgroupTransferTasksFtraceEvent::SharedCtor(
1770 ::_pb::Arena* arena, bool is_message_owned) {
1771 (void)arena;
1772 (void)is_message_owned;
1773 new (&_impl_) Impl_{
1774 decltype(_impl_._has_bits_){}
1775 , /*decltype(_impl_._cached_size_)*/{}
1776 , decltype(_impl_.comm_){}
1777 , decltype(_impl_.cname_){}
1778 , decltype(_impl_.dst_path_){}
1779 , decltype(_impl_.dst_root_){0}
1780 , decltype(_impl_.dst_id_){0}
1781 , decltype(_impl_.pid_){0}
1782 , decltype(_impl_.dst_level_){0}
1783 };
1784 _impl_.comm_.InitDefault();
1785 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1786 _impl_.comm_.Set("", GetArenaForAllocation());
1787 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1788 _impl_.cname_.InitDefault();
1789 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1790 _impl_.cname_.Set("", GetArenaForAllocation());
1791 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1792 _impl_.dst_path_.InitDefault();
1793 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1794 _impl_.dst_path_.Set("", GetArenaForAllocation());
1795 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1796 }
1797
~CgroupTransferTasksFtraceEvent()1798 CgroupTransferTasksFtraceEvent::~CgroupTransferTasksFtraceEvent() {
1799 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupTransferTasksFtraceEvent)
1800 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1801 (void)arena;
1802 return;
1803 }
1804 SharedDtor();
1805 }
1806
SharedDtor()1807 inline void CgroupTransferTasksFtraceEvent::SharedDtor() {
1808 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1809 _impl_.comm_.Destroy();
1810 _impl_.cname_.Destroy();
1811 _impl_.dst_path_.Destroy();
1812 }
1813
SetCachedSize(int size) const1814 void CgroupTransferTasksFtraceEvent::SetCachedSize(int size) const {
1815 _impl_._cached_size_.Set(size);
1816 }
1817
Clear()1818 void CgroupTransferTasksFtraceEvent::Clear() {
1819 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupTransferTasksFtraceEvent)
1820 ::uint32_t cached_has_bits = 0;
1821 // Prevent compiler warnings about cached_has_bits being unused
1822 (void) cached_has_bits;
1823
1824 cached_has_bits = _impl_._has_bits_[0];
1825 if (cached_has_bits & 0x00000007u) {
1826 if (cached_has_bits & 0x00000001u) {
1827 _impl_.comm_.ClearNonDefaultToEmpty();
1828 }
1829 if (cached_has_bits & 0x00000002u) {
1830 _impl_.cname_.ClearNonDefaultToEmpty();
1831 }
1832 if (cached_has_bits & 0x00000004u) {
1833 _impl_.dst_path_.ClearNonDefaultToEmpty();
1834 }
1835 }
1836 if (cached_has_bits & 0x00000078u) {
1837 ::memset(&_impl_.dst_root_, 0, static_cast<size_t>(
1838 reinterpret_cast<char*>(&_impl_.dst_level_) -
1839 reinterpret_cast<char*>(&_impl_.dst_root_)) + sizeof(_impl_.dst_level_));
1840 }
1841 _impl_._has_bits_.Clear();
1842 _internal_metadata_.Clear<std::string>();
1843 }
1844
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1845 const char* CgroupTransferTasksFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1846 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1847 _Internal::HasBits has_bits{};
1848 while (!ctx->Done(&ptr)) {
1849 ::uint32_t tag;
1850 ptr = ::_pbi::ReadTag(ptr, &tag);
1851 switch (tag >> 3) {
1852 // optional int32 dst_root = 1;
1853 case 1:
1854 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1855 _Internal::set_has_dst_root(&has_bits);
1856 _impl_.dst_root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1857 CHK_(ptr);
1858 } else {
1859 goto handle_unusual;
1860 }
1861 continue;
1862 // optional int32 dst_id = 2;
1863 case 2:
1864 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1865 _Internal::set_has_dst_id(&has_bits);
1866 _impl_.dst_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1867 CHK_(ptr);
1868 } else {
1869 goto handle_unusual;
1870 }
1871 continue;
1872 // optional int32 pid = 3;
1873 case 3:
1874 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1875 _Internal::set_has_pid(&has_bits);
1876 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1877 CHK_(ptr);
1878 } else {
1879 goto handle_unusual;
1880 }
1881 continue;
1882 // optional string comm = 4;
1883 case 4:
1884 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1885 auto str = _internal_mutable_comm();
1886 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1887 CHK_(ptr);
1888 } else {
1889 goto handle_unusual;
1890 }
1891 continue;
1892 // optional string cname = 5;
1893 case 5:
1894 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1895 auto str = _internal_mutable_cname();
1896 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1897 CHK_(ptr);
1898 } else {
1899 goto handle_unusual;
1900 }
1901 continue;
1902 // optional int32 dst_level = 6;
1903 case 6:
1904 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1905 _Internal::set_has_dst_level(&has_bits);
1906 _impl_.dst_level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1907 CHK_(ptr);
1908 } else {
1909 goto handle_unusual;
1910 }
1911 continue;
1912 // optional string dst_path = 7;
1913 case 7:
1914 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 58)) {
1915 auto str = _internal_mutable_dst_path();
1916 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1917 CHK_(ptr);
1918 } else {
1919 goto handle_unusual;
1920 }
1921 continue;
1922 default:
1923 goto handle_unusual;
1924 } // switch
1925 handle_unusual:
1926 if ((tag == 0) || ((tag & 7) == 4)) {
1927 CHK_(ptr);
1928 ctx->SetLastTag(tag);
1929 goto message_done;
1930 }
1931 ptr = UnknownFieldParse(
1932 tag,
1933 _internal_metadata_.mutable_unknown_fields<std::string>(),
1934 ptr, ctx);
1935 CHK_(ptr != nullptr);
1936 } // while
1937 message_done:
1938 _impl_._has_bits_.Or(has_bits);
1939 return ptr;
1940 failure:
1941 ptr = nullptr;
1942 goto message_done;
1943 #undef CHK_
1944 }
1945
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1946 ::uint8_t* CgroupTransferTasksFtraceEvent::_InternalSerialize(
1947 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1948 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupTransferTasksFtraceEvent)
1949 ::uint32_t cached_has_bits = 0;
1950 (void) cached_has_bits;
1951
1952 cached_has_bits = _impl_._has_bits_[0];
1953 // optional int32 dst_root = 1;
1954 if (cached_has_bits & 0x00000008u) {
1955 target = stream->EnsureSpace(target);
1956 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_dst_root(), target);
1957 }
1958
1959 // optional int32 dst_id = 2;
1960 if (cached_has_bits & 0x00000010u) {
1961 target = stream->EnsureSpace(target);
1962 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_dst_id(), target);
1963 }
1964
1965 // optional int32 pid = 3;
1966 if (cached_has_bits & 0x00000020u) {
1967 target = stream->EnsureSpace(target);
1968 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_pid(), target);
1969 }
1970
1971 // optional string comm = 4;
1972 if (cached_has_bits & 0x00000001u) {
1973 target = stream->WriteStringMaybeAliased(
1974 4, this->_internal_comm(), target);
1975 }
1976
1977 // optional string cname = 5;
1978 if (cached_has_bits & 0x00000002u) {
1979 target = stream->WriteStringMaybeAliased(
1980 5, this->_internal_cname(), target);
1981 }
1982
1983 // optional int32 dst_level = 6;
1984 if (cached_has_bits & 0x00000040u) {
1985 target = stream->EnsureSpace(target);
1986 target = ::_pbi::WireFormatLite::WriteInt32ToArray(6, this->_internal_dst_level(), target);
1987 }
1988
1989 // optional string dst_path = 7;
1990 if (cached_has_bits & 0x00000004u) {
1991 target = stream->WriteStringMaybeAliased(
1992 7, this->_internal_dst_path(), target);
1993 }
1994
1995 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1996 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1997 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1998 }
1999 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupTransferTasksFtraceEvent)
2000 return target;
2001 }
2002
ByteSizeLong() const2003 size_t CgroupTransferTasksFtraceEvent::ByteSizeLong() const {
2004 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupTransferTasksFtraceEvent)
2005 size_t total_size = 0;
2006
2007 ::uint32_t cached_has_bits = 0;
2008 // Prevent compiler warnings about cached_has_bits being unused
2009 (void) cached_has_bits;
2010
2011 cached_has_bits = _impl_._has_bits_[0];
2012 if (cached_has_bits & 0x0000007fu) {
2013 // optional string comm = 4;
2014 if (cached_has_bits & 0x00000001u) {
2015 total_size += 1 +
2016 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2017 this->_internal_comm());
2018 }
2019
2020 // optional string cname = 5;
2021 if (cached_has_bits & 0x00000002u) {
2022 total_size += 1 +
2023 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2024 this->_internal_cname());
2025 }
2026
2027 // optional string dst_path = 7;
2028 if (cached_has_bits & 0x00000004u) {
2029 total_size += 1 +
2030 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2031 this->_internal_dst_path());
2032 }
2033
2034 // optional int32 dst_root = 1;
2035 if (cached_has_bits & 0x00000008u) {
2036 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dst_root());
2037 }
2038
2039 // optional int32 dst_id = 2;
2040 if (cached_has_bits & 0x00000010u) {
2041 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dst_id());
2042 }
2043
2044 // optional int32 pid = 3;
2045 if (cached_has_bits & 0x00000020u) {
2046 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
2047 }
2048
2049 // optional int32 dst_level = 6;
2050 if (cached_has_bits & 0x00000040u) {
2051 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dst_level());
2052 }
2053
2054 }
2055 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2056 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2057 }
2058 int cached_size = ::_pbi::ToCachedSize(total_size);
2059 SetCachedSize(cached_size);
2060 return total_size;
2061 }
2062
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2063 void CgroupTransferTasksFtraceEvent::CheckTypeAndMergeFrom(
2064 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2065 MergeFrom(*::_pbi::DownCast<const CgroupTransferTasksFtraceEvent*>(
2066 &from));
2067 }
2068
MergeFrom(const CgroupTransferTasksFtraceEvent & from)2069 void CgroupTransferTasksFtraceEvent::MergeFrom(const CgroupTransferTasksFtraceEvent& from) {
2070 CgroupTransferTasksFtraceEvent* const _this = this;
2071 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupTransferTasksFtraceEvent)
2072 GOOGLE_DCHECK_NE(&from, _this);
2073 ::uint32_t cached_has_bits = 0;
2074 (void) cached_has_bits;
2075
2076 cached_has_bits = from._impl_._has_bits_[0];
2077 if (cached_has_bits & 0x0000007fu) {
2078 if (cached_has_bits & 0x00000001u) {
2079 _this->_internal_set_comm(from._internal_comm());
2080 }
2081 if (cached_has_bits & 0x00000002u) {
2082 _this->_internal_set_cname(from._internal_cname());
2083 }
2084 if (cached_has_bits & 0x00000004u) {
2085 _this->_internal_set_dst_path(from._internal_dst_path());
2086 }
2087 if (cached_has_bits & 0x00000008u) {
2088 _this->_impl_.dst_root_ = from._impl_.dst_root_;
2089 }
2090 if (cached_has_bits & 0x00000010u) {
2091 _this->_impl_.dst_id_ = from._impl_.dst_id_;
2092 }
2093 if (cached_has_bits & 0x00000020u) {
2094 _this->_impl_.pid_ = from._impl_.pid_;
2095 }
2096 if (cached_has_bits & 0x00000040u) {
2097 _this->_impl_.dst_level_ = from._impl_.dst_level_;
2098 }
2099 _this->_impl_._has_bits_[0] |= cached_has_bits;
2100 }
2101 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2102 }
2103
CopyFrom(const CgroupTransferTasksFtraceEvent & from)2104 void CgroupTransferTasksFtraceEvent::CopyFrom(const CgroupTransferTasksFtraceEvent& from) {
2105 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupTransferTasksFtraceEvent)
2106 if (&from == this) return;
2107 Clear();
2108 MergeFrom(from);
2109 }
2110
IsInitialized() const2111 bool CgroupTransferTasksFtraceEvent::IsInitialized() const {
2112 return true;
2113 }
2114
InternalSwap(CgroupTransferTasksFtraceEvent * other)2115 void CgroupTransferTasksFtraceEvent::InternalSwap(CgroupTransferTasksFtraceEvent* other) {
2116 using std::swap;
2117 auto* lhs_arena = GetArenaForAllocation();
2118 auto* rhs_arena = other->GetArenaForAllocation();
2119 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2120 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2121 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2122 &_impl_.comm_, lhs_arena,
2123 &other->_impl_.comm_, rhs_arena
2124 );
2125 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2126 &_impl_.cname_, lhs_arena,
2127 &other->_impl_.cname_, rhs_arena
2128 );
2129 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2130 &_impl_.dst_path_, lhs_arena,
2131 &other->_impl_.dst_path_, rhs_arena
2132 );
2133 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2134 PROTOBUF_FIELD_OFFSET(CgroupTransferTasksFtraceEvent, _impl_.dst_level_)
2135 + sizeof(CgroupTransferTasksFtraceEvent::_impl_.dst_level_) // NOLINT
2136 - PROTOBUF_FIELD_OFFSET(CgroupTransferTasksFtraceEvent, _impl_.dst_root_)>(
2137 reinterpret_cast<char*>(&_impl_.dst_root_),
2138 reinterpret_cast<char*>(&other->_impl_.dst_root_));
2139 }
2140
GetTypeName() const2141 std::string CgroupTransferTasksFtraceEvent::GetTypeName() const {
2142 return "perfetto.protos.CgroupTransferTasksFtraceEvent";
2143 }
2144
2145
2146 // ===================================================================
2147
2148 class CgroupDestroyRootFtraceEvent::_Internal {
2149 public:
2150 using HasBits = decltype(std::declval<CgroupDestroyRootFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)2151 static void set_has_root(HasBits* has_bits) {
2152 (*has_bits)[0] |= 2u;
2153 }
set_has_ss_mask(HasBits * has_bits)2154 static void set_has_ss_mask(HasBits* has_bits) {
2155 (*has_bits)[0] |= 4u;
2156 }
set_has_name(HasBits * has_bits)2157 static void set_has_name(HasBits* has_bits) {
2158 (*has_bits)[0] |= 1u;
2159 }
2160 };
2161
CgroupDestroyRootFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2162 CgroupDestroyRootFtraceEvent::CgroupDestroyRootFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2163 bool is_message_owned)
2164 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2165 SharedCtor(arena, is_message_owned);
2166 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupDestroyRootFtraceEvent)
2167 }
CgroupDestroyRootFtraceEvent(const CgroupDestroyRootFtraceEvent & from)2168 CgroupDestroyRootFtraceEvent::CgroupDestroyRootFtraceEvent(const CgroupDestroyRootFtraceEvent& from)
2169 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2170 CgroupDestroyRootFtraceEvent* const _this = this; (void)_this;
2171 new (&_impl_) Impl_{
2172 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2173 , /*decltype(_impl_._cached_size_)*/{}
2174 , decltype(_impl_.name_){}
2175 , decltype(_impl_.root_){}
2176 , decltype(_impl_.ss_mask_){}};
2177
2178 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2179 _impl_.name_.InitDefault();
2180 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2181 _impl_.name_.Set("", GetArenaForAllocation());
2182 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2183 if (from._internal_has_name()) {
2184 _this->_impl_.name_.Set(from._internal_name(),
2185 _this->GetArenaForAllocation());
2186 }
2187 ::memcpy(&_impl_.root_, &from._impl_.root_,
2188 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ss_mask_) -
2189 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.ss_mask_));
2190 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupDestroyRootFtraceEvent)
2191 }
2192
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2193 inline void CgroupDestroyRootFtraceEvent::SharedCtor(
2194 ::_pb::Arena* arena, bool is_message_owned) {
2195 (void)arena;
2196 (void)is_message_owned;
2197 new (&_impl_) Impl_{
2198 decltype(_impl_._has_bits_){}
2199 , /*decltype(_impl_._cached_size_)*/{}
2200 , decltype(_impl_.name_){}
2201 , decltype(_impl_.root_){0}
2202 , decltype(_impl_.ss_mask_){0u}
2203 };
2204 _impl_.name_.InitDefault();
2205 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2206 _impl_.name_.Set("", GetArenaForAllocation());
2207 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2208 }
2209
~CgroupDestroyRootFtraceEvent()2210 CgroupDestroyRootFtraceEvent::~CgroupDestroyRootFtraceEvent() {
2211 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupDestroyRootFtraceEvent)
2212 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2213 (void)arena;
2214 return;
2215 }
2216 SharedDtor();
2217 }
2218
SharedDtor()2219 inline void CgroupDestroyRootFtraceEvent::SharedDtor() {
2220 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2221 _impl_.name_.Destroy();
2222 }
2223
SetCachedSize(int size) const2224 void CgroupDestroyRootFtraceEvent::SetCachedSize(int size) const {
2225 _impl_._cached_size_.Set(size);
2226 }
2227
Clear()2228 void CgroupDestroyRootFtraceEvent::Clear() {
2229 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupDestroyRootFtraceEvent)
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 & 0x00000001u) {
2236 _impl_.name_.ClearNonDefaultToEmpty();
2237 }
2238 if (cached_has_bits & 0x00000006u) {
2239 ::memset(&_impl_.root_, 0, static_cast<size_t>(
2240 reinterpret_cast<char*>(&_impl_.ss_mask_) -
2241 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.ss_mask_));
2242 }
2243 _impl_._has_bits_.Clear();
2244 _internal_metadata_.Clear<std::string>();
2245 }
2246
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2247 const char* CgroupDestroyRootFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2248 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2249 _Internal::HasBits has_bits{};
2250 while (!ctx->Done(&ptr)) {
2251 ::uint32_t tag;
2252 ptr = ::_pbi::ReadTag(ptr, &tag);
2253 switch (tag >> 3) {
2254 // optional int32 root = 1;
2255 case 1:
2256 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2257 _Internal::set_has_root(&has_bits);
2258 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2259 CHK_(ptr);
2260 } else {
2261 goto handle_unusual;
2262 }
2263 continue;
2264 // optional uint32 ss_mask = 2;
2265 case 2:
2266 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2267 _Internal::set_has_ss_mask(&has_bits);
2268 _impl_.ss_mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2269 CHK_(ptr);
2270 } else {
2271 goto handle_unusual;
2272 }
2273 continue;
2274 // optional string name = 3;
2275 case 3:
2276 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2277 auto str = _internal_mutable_name();
2278 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2279 CHK_(ptr);
2280 } else {
2281 goto handle_unusual;
2282 }
2283 continue;
2284 default:
2285 goto handle_unusual;
2286 } // switch
2287 handle_unusual:
2288 if ((tag == 0) || ((tag & 7) == 4)) {
2289 CHK_(ptr);
2290 ctx->SetLastTag(tag);
2291 goto message_done;
2292 }
2293 ptr = UnknownFieldParse(
2294 tag,
2295 _internal_metadata_.mutable_unknown_fields<std::string>(),
2296 ptr, ctx);
2297 CHK_(ptr != nullptr);
2298 } // while
2299 message_done:
2300 _impl_._has_bits_.Or(has_bits);
2301 return ptr;
2302 failure:
2303 ptr = nullptr;
2304 goto message_done;
2305 #undef CHK_
2306 }
2307
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2308 ::uint8_t* CgroupDestroyRootFtraceEvent::_InternalSerialize(
2309 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2310 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupDestroyRootFtraceEvent)
2311 ::uint32_t cached_has_bits = 0;
2312 (void) cached_has_bits;
2313
2314 cached_has_bits = _impl_._has_bits_[0];
2315 // optional int32 root = 1;
2316 if (cached_has_bits & 0x00000002u) {
2317 target = stream->EnsureSpace(target);
2318 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
2319 }
2320
2321 // optional uint32 ss_mask = 2;
2322 if (cached_has_bits & 0x00000004u) {
2323 target = stream->EnsureSpace(target);
2324 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ss_mask(), target);
2325 }
2326
2327 // optional string name = 3;
2328 if (cached_has_bits & 0x00000001u) {
2329 target = stream->WriteStringMaybeAliased(
2330 3, this->_internal_name(), target);
2331 }
2332
2333 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2334 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2335 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2336 }
2337 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupDestroyRootFtraceEvent)
2338 return target;
2339 }
2340
ByteSizeLong() const2341 size_t CgroupDestroyRootFtraceEvent::ByteSizeLong() const {
2342 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupDestroyRootFtraceEvent)
2343 size_t total_size = 0;
2344
2345 ::uint32_t cached_has_bits = 0;
2346 // Prevent compiler warnings about cached_has_bits being unused
2347 (void) cached_has_bits;
2348
2349 cached_has_bits = _impl_._has_bits_[0];
2350 if (cached_has_bits & 0x00000007u) {
2351 // optional string name = 3;
2352 if (cached_has_bits & 0x00000001u) {
2353 total_size += 1 +
2354 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2355 this->_internal_name());
2356 }
2357
2358 // optional int32 root = 1;
2359 if (cached_has_bits & 0x00000002u) {
2360 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
2361 }
2362
2363 // optional uint32 ss_mask = 2;
2364 if (cached_has_bits & 0x00000004u) {
2365 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ss_mask());
2366 }
2367
2368 }
2369 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2370 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2371 }
2372 int cached_size = ::_pbi::ToCachedSize(total_size);
2373 SetCachedSize(cached_size);
2374 return total_size;
2375 }
2376
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2377 void CgroupDestroyRootFtraceEvent::CheckTypeAndMergeFrom(
2378 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2379 MergeFrom(*::_pbi::DownCast<const CgroupDestroyRootFtraceEvent*>(
2380 &from));
2381 }
2382
MergeFrom(const CgroupDestroyRootFtraceEvent & from)2383 void CgroupDestroyRootFtraceEvent::MergeFrom(const CgroupDestroyRootFtraceEvent& from) {
2384 CgroupDestroyRootFtraceEvent* const _this = this;
2385 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupDestroyRootFtraceEvent)
2386 GOOGLE_DCHECK_NE(&from, _this);
2387 ::uint32_t cached_has_bits = 0;
2388 (void) cached_has_bits;
2389
2390 cached_has_bits = from._impl_._has_bits_[0];
2391 if (cached_has_bits & 0x00000007u) {
2392 if (cached_has_bits & 0x00000001u) {
2393 _this->_internal_set_name(from._internal_name());
2394 }
2395 if (cached_has_bits & 0x00000002u) {
2396 _this->_impl_.root_ = from._impl_.root_;
2397 }
2398 if (cached_has_bits & 0x00000004u) {
2399 _this->_impl_.ss_mask_ = from._impl_.ss_mask_;
2400 }
2401 _this->_impl_._has_bits_[0] |= cached_has_bits;
2402 }
2403 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2404 }
2405
CopyFrom(const CgroupDestroyRootFtraceEvent & from)2406 void CgroupDestroyRootFtraceEvent::CopyFrom(const CgroupDestroyRootFtraceEvent& from) {
2407 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupDestroyRootFtraceEvent)
2408 if (&from == this) return;
2409 Clear();
2410 MergeFrom(from);
2411 }
2412
IsInitialized() const2413 bool CgroupDestroyRootFtraceEvent::IsInitialized() const {
2414 return true;
2415 }
2416
InternalSwap(CgroupDestroyRootFtraceEvent * other)2417 void CgroupDestroyRootFtraceEvent::InternalSwap(CgroupDestroyRootFtraceEvent* other) {
2418 using std::swap;
2419 auto* lhs_arena = GetArenaForAllocation();
2420 auto* rhs_arena = other->GetArenaForAllocation();
2421 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2422 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2423 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2424 &_impl_.name_, lhs_arena,
2425 &other->_impl_.name_, rhs_arena
2426 );
2427 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2428 PROTOBUF_FIELD_OFFSET(CgroupDestroyRootFtraceEvent, _impl_.ss_mask_)
2429 + sizeof(CgroupDestroyRootFtraceEvent::_impl_.ss_mask_) // NOLINT
2430 - PROTOBUF_FIELD_OFFSET(CgroupDestroyRootFtraceEvent, _impl_.root_)>(
2431 reinterpret_cast<char*>(&_impl_.root_),
2432 reinterpret_cast<char*>(&other->_impl_.root_));
2433 }
2434
GetTypeName() const2435 std::string CgroupDestroyRootFtraceEvent::GetTypeName() const {
2436 return "perfetto.protos.CgroupDestroyRootFtraceEvent";
2437 }
2438
2439
2440 // ===================================================================
2441
2442 class CgroupReleaseFtraceEvent::_Internal {
2443 public:
2444 using HasBits = decltype(std::declval<CgroupReleaseFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)2445 static void set_has_root(HasBits* has_bits) {
2446 (*has_bits)[0] |= 4u;
2447 }
set_has_id(HasBits * has_bits)2448 static void set_has_id(HasBits* has_bits) {
2449 (*has_bits)[0] |= 8u;
2450 }
set_has_cname(HasBits * has_bits)2451 static void set_has_cname(HasBits* has_bits) {
2452 (*has_bits)[0] |= 1u;
2453 }
set_has_level(HasBits * has_bits)2454 static void set_has_level(HasBits* has_bits) {
2455 (*has_bits)[0] |= 16u;
2456 }
set_has_path(HasBits * has_bits)2457 static void set_has_path(HasBits* has_bits) {
2458 (*has_bits)[0] |= 2u;
2459 }
2460 };
2461
CgroupReleaseFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2462 CgroupReleaseFtraceEvent::CgroupReleaseFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2463 bool is_message_owned)
2464 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2465 SharedCtor(arena, is_message_owned);
2466 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupReleaseFtraceEvent)
2467 }
CgroupReleaseFtraceEvent(const CgroupReleaseFtraceEvent & from)2468 CgroupReleaseFtraceEvent::CgroupReleaseFtraceEvent(const CgroupReleaseFtraceEvent& from)
2469 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2470 CgroupReleaseFtraceEvent* const _this = this; (void)_this;
2471 new (&_impl_) Impl_{
2472 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2473 , /*decltype(_impl_._cached_size_)*/{}
2474 , decltype(_impl_.cname_){}
2475 , decltype(_impl_.path_){}
2476 , decltype(_impl_.root_){}
2477 , decltype(_impl_.id_){}
2478 , decltype(_impl_.level_){}};
2479
2480 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2481 _impl_.cname_.InitDefault();
2482 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2483 _impl_.cname_.Set("", GetArenaForAllocation());
2484 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2485 if (from._internal_has_cname()) {
2486 _this->_impl_.cname_.Set(from._internal_cname(),
2487 _this->GetArenaForAllocation());
2488 }
2489 _impl_.path_.InitDefault();
2490 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2491 _impl_.path_.Set("", GetArenaForAllocation());
2492 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2493 if (from._internal_has_path()) {
2494 _this->_impl_.path_.Set(from._internal_path(),
2495 _this->GetArenaForAllocation());
2496 }
2497 ::memcpy(&_impl_.root_, &from._impl_.root_,
2498 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.level_) -
2499 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
2500 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupReleaseFtraceEvent)
2501 }
2502
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2503 inline void CgroupReleaseFtraceEvent::SharedCtor(
2504 ::_pb::Arena* arena, bool is_message_owned) {
2505 (void)arena;
2506 (void)is_message_owned;
2507 new (&_impl_) Impl_{
2508 decltype(_impl_._has_bits_){}
2509 , /*decltype(_impl_._cached_size_)*/{}
2510 , decltype(_impl_.cname_){}
2511 , decltype(_impl_.path_){}
2512 , decltype(_impl_.root_){0}
2513 , decltype(_impl_.id_){0}
2514 , decltype(_impl_.level_){0}
2515 };
2516 _impl_.cname_.InitDefault();
2517 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2518 _impl_.cname_.Set("", GetArenaForAllocation());
2519 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2520 _impl_.path_.InitDefault();
2521 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2522 _impl_.path_.Set("", GetArenaForAllocation());
2523 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2524 }
2525
~CgroupReleaseFtraceEvent()2526 CgroupReleaseFtraceEvent::~CgroupReleaseFtraceEvent() {
2527 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupReleaseFtraceEvent)
2528 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2529 (void)arena;
2530 return;
2531 }
2532 SharedDtor();
2533 }
2534
SharedDtor()2535 inline void CgroupReleaseFtraceEvent::SharedDtor() {
2536 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2537 _impl_.cname_.Destroy();
2538 _impl_.path_.Destroy();
2539 }
2540
SetCachedSize(int size) const2541 void CgroupReleaseFtraceEvent::SetCachedSize(int size) const {
2542 _impl_._cached_size_.Set(size);
2543 }
2544
Clear()2545 void CgroupReleaseFtraceEvent::Clear() {
2546 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupReleaseFtraceEvent)
2547 ::uint32_t cached_has_bits = 0;
2548 // Prevent compiler warnings about cached_has_bits being unused
2549 (void) cached_has_bits;
2550
2551 cached_has_bits = _impl_._has_bits_[0];
2552 if (cached_has_bits & 0x00000003u) {
2553 if (cached_has_bits & 0x00000001u) {
2554 _impl_.cname_.ClearNonDefaultToEmpty();
2555 }
2556 if (cached_has_bits & 0x00000002u) {
2557 _impl_.path_.ClearNonDefaultToEmpty();
2558 }
2559 }
2560 if (cached_has_bits & 0x0000001cu) {
2561 ::memset(&_impl_.root_, 0, static_cast<size_t>(
2562 reinterpret_cast<char*>(&_impl_.level_) -
2563 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
2564 }
2565 _impl_._has_bits_.Clear();
2566 _internal_metadata_.Clear<std::string>();
2567 }
2568
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2569 const char* CgroupReleaseFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2570 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2571 _Internal::HasBits has_bits{};
2572 while (!ctx->Done(&ptr)) {
2573 ::uint32_t tag;
2574 ptr = ::_pbi::ReadTag(ptr, &tag);
2575 switch (tag >> 3) {
2576 // optional int32 root = 1;
2577 case 1:
2578 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2579 _Internal::set_has_root(&has_bits);
2580 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2581 CHK_(ptr);
2582 } else {
2583 goto handle_unusual;
2584 }
2585 continue;
2586 // optional int32 id = 2;
2587 case 2:
2588 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2589 _Internal::set_has_id(&has_bits);
2590 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2591 CHK_(ptr);
2592 } else {
2593 goto handle_unusual;
2594 }
2595 continue;
2596 // optional string cname = 3;
2597 case 3:
2598 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2599 auto str = _internal_mutable_cname();
2600 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2601 CHK_(ptr);
2602 } else {
2603 goto handle_unusual;
2604 }
2605 continue;
2606 // optional int32 level = 4;
2607 case 4:
2608 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2609 _Internal::set_has_level(&has_bits);
2610 _impl_.level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2611 CHK_(ptr);
2612 } else {
2613 goto handle_unusual;
2614 }
2615 continue;
2616 // optional string path = 5;
2617 case 5:
2618 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2619 auto str = _internal_mutable_path();
2620 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2621 CHK_(ptr);
2622 } else {
2623 goto handle_unusual;
2624 }
2625 continue;
2626 default:
2627 goto handle_unusual;
2628 } // switch
2629 handle_unusual:
2630 if ((tag == 0) || ((tag & 7) == 4)) {
2631 CHK_(ptr);
2632 ctx->SetLastTag(tag);
2633 goto message_done;
2634 }
2635 ptr = UnknownFieldParse(
2636 tag,
2637 _internal_metadata_.mutable_unknown_fields<std::string>(),
2638 ptr, ctx);
2639 CHK_(ptr != nullptr);
2640 } // while
2641 message_done:
2642 _impl_._has_bits_.Or(has_bits);
2643 return ptr;
2644 failure:
2645 ptr = nullptr;
2646 goto message_done;
2647 #undef CHK_
2648 }
2649
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2650 ::uint8_t* CgroupReleaseFtraceEvent::_InternalSerialize(
2651 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2652 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupReleaseFtraceEvent)
2653 ::uint32_t cached_has_bits = 0;
2654 (void) cached_has_bits;
2655
2656 cached_has_bits = _impl_._has_bits_[0];
2657 // optional int32 root = 1;
2658 if (cached_has_bits & 0x00000004u) {
2659 target = stream->EnsureSpace(target);
2660 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
2661 }
2662
2663 // optional int32 id = 2;
2664 if (cached_has_bits & 0x00000008u) {
2665 target = stream->EnsureSpace(target);
2666 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_id(), target);
2667 }
2668
2669 // optional string cname = 3;
2670 if (cached_has_bits & 0x00000001u) {
2671 target = stream->WriteStringMaybeAliased(
2672 3, this->_internal_cname(), target);
2673 }
2674
2675 // optional int32 level = 4;
2676 if (cached_has_bits & 0x00000010u) {
2677 target = stream->EnsureSpace(target);
2678 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_level(), target);
2679 }
2680
2681 // optional string path = 5;
2682 if (cached_has_bits & 0x00000002u) {
2683 target = stream->WriteStringMaybeAliased(
2684 5, this->_internal_path(), target);
2685 }
2686
2687 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2688 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2689 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2690 }
2691 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupReleaseFtraceEvent)
2692 return target;
2693 }
2694
ByteSizeLong() const2695 size_t CgroupReleaseFtraceEvent::ByteSizeLong() const {
2696 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupReleaseFtraceEvent)
2697 size_t total_size = 0;
2698
2699 ::uint32_t cached_has_bits = 0;
2700 // Prevent compiler warnings about cached_has_bits being unused
2701 (void) cached_has_bits;
2702
2703 cached_has_bits = _impl_._has_bits_[0];
2704 if (cached_has_bits & 0x0000001fu) {
2705 // optional string cname = 3;
2706 if (cached_has_bits & 0x00000001u) {
2707 total_size += 1 +
2708 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2709 this->_internal_cname());
2710 }
2711
2712 // optional string path = 5;
2713 if (cached_has_bits & 0x00000002u) {
2714 total_size += 1 +
2715 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2716 this->_internal_path());
2717 }
2718
2719 // optional int32 root = 1;
2720 if (cached_has_bits & 0x00000004u) {
2721 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
2722 }
2723
2724 // optional int32 id = 2;
2725 if (cached_has_bits & 0x00000008u) {
2726 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
2727 }
2728
2729 // optional int32 level = 4;
2730 if (cached_has_bits & 0x00000010u) {
2731 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_level());
2732 }
2733
2734 }
2735 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2736 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2737 }
2738 int cached_size = ::_pbi::ToCachedSize(total_size);
2739 SetCachedSize(cached_size);
2740 return total_size;
2741 }
2742
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2743 void CgroupReleaseFtraceEvent::CheckTypeAndMergeFrom(
2744 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2745 MergeFrom(*::_pbi::DownCast<const CgroupReleaseFtraceEvent*>(
2746 &from));
2747 }
2748
MergeFrom(const CgroupReleaseFtraceEvent & from)2749 void CgroupReleaseFtraceEvent::MergeFrom(const CgroupReleaseFtraceEvent& from) {
2750 CgroupReleaseFtraceEvent* const _this = this;
2751 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupReleaseFtraceEvent)
2752 GOOGLE_DCHECK_NE(&from, _this);
2753 ::uint32_t cached_has_bits = 0;
2754 (void) cached_has_bits;
2755
2756 cached_has_bits = from._impl_._has_bits_[0];
2757 if (cached_has_bits & 0x0000001fu) {
2758 if (cached_has_bits & 0x00000001u) {
2759 _this->_internal_set_cname(from._internal_cname());
2760 }
2761 if (cached_has_bits & 0x00000002u) {
2762 _this->_internal_set_path(from._internal_path());
2763 }
2764 if (cached_has_bits & 0x00000004u) {
2765 _this->_impl_.root_ = from._impl_.root_;
2766 }
2767 if (cached_has_bits & 0x00000008u) {
2768 _this->_impl_.id_ = from._impl_.id_;
2769 }
2770 if (cached_has_bits & 0x00000010u) {
2771 _this->_impl_.level_ = from._impl_.level_;
2772 }
2773 _this->_impl_._has_bits_[0] |= cached_has_bits;
2774 }
2775 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2776 }
2777
CopyFrom(const CgroupReleaseFtraceEvent & from)2778 void CgroupReleaseFtraceEvent::CopyFrom(const CgroupReleaseFtraceEvent& from) {
2779 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupReleaseFtraceEvent)
2780 if (&from == this) return;
2781 Clear();
2782 MergeFrom(from);
2783 }
2784
IsInitialized() const2785 bool CgroupReleaseFtraceEvent::IsInitialized() const {
2786 return true;
2787 }
2788
InternalSwap(CgroupReleaseFtraceEvent * other)2789 void CgroupReleaseFtraceEvent::InternalSwap(CgroupReleaseFtraceEvent* other) {
2790 using std::swap;
2791 auto* lhs_arena = GetArenaForAllocation();
2792 auto* rhs_arena = other->GetArenaForAllocation();
2793 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2794 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2795 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2796 &_impl_.cname_, lhs_arena,
2797 &other->_impl_.cname_, rhs_arena
2798 );
2799 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2800 &_impl_.path_, lhs_arena,
2801 &other->_impl_.path_, rhs_arena
2802 );
2803 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2804 PROTOBUF_FIELD_OFFSET(CgroupReleaseFtraceEvent, _impl_.level_)
2805 + sizeof(CgroupReleaseFtraceEvent::_impl_.level_) // NOLINT
2806 - PROTOBUF_FIELD_OFFSET(CgroupReleaseFtraceEvent, _impl_.root_)>(
2807 reinterpret_cast<char*>(&_impl_.root_),
2808 reinterpret_cast<char*>(&other->_impl_.root_));
2809 }
2810
GetTypeName() const2811 std::string CgroupReleaseFtraceEvent::GetTypeName() const {
2812 return "perfetto.protos.CgroupReleaseFtraceEvent";
2813 }
2814
2815
2816 // ===================================================================
2817
2818 class CgroupRenameFtraceEvent::_Internal {
2819 public:
2820 using HasBits = decltype(std::declval<CgroupRenameFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)2821 static void set_has_root(HasBits* has_bits) {
2822 (*has_bits)[0] |= 4u;
2823 }
set_has_id(HasBits * has_bits)2824 static void set_has_id(HasBits* has_bits) {
2825 (*has_bits)[0] |= 8u;
2826 }
set_has_cname(HasBits * has_bits)2827 static void set_has_cname(HasBits* has_bits) {
2828 (*has_bits)[0] |= 1u;
2829 }
set_has_level(HasBits * has_bits)2830 static void set_has_level(HasBits* has_bits) {
2831 (*has_bits)[0] |= 16u;
2832 }
set_has_path(HasBits * has_bits)2833 static void set_has_path(HasBits* has_bits) {
2834 (*has_bits)[0] |= 2u;
2835 }
2836 };
2837
CgroupRenameFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)2838 CgroupRenameFtraceEvent::CgroupRenameFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
2839 bool is_message_owned)
2840 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
2841 SharedCtor(arena, is_message_owned);
2842 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupRenameFtraceEvent)
2843 }
CgroupRenameFtraceEvent(const CgroupRenameFtraceEvent & from)2844 CgroupRenameFtraceEvent::CgroupRenameFtraceEvent(const CgroupRenameFtraceEvent& from)
2845 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
2846 CgroupRenameFtraceEvent* const _this = this; (void)_this;
2847 new (&_impl_) Impl_{
2848 decltype(_impl_._has_bits_){from._impl_._has_bits_}
2849 , /*decltype(_impl_._cached_size_)*/{}
2850 , decltype(_impl_.cname_){}
2851 , decltype(_impl_.path_){}
2852 , decltype(_impl_.root_){}
2853 , decltype(_impl_.id_){}
2854 , decltype(_impl_.level_){}};
2855
2856 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2857 _impl_.cname_.InitDefault();
2858 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2859 _impl_.cname_.Set("", GetArenaForAllocation());
2860 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2861 if (from._internal_has_cname()) {
2862 _this->_impl_.cname_.Set(from._internal_cname(),
2863 _this->GetArenaForAllocation());
2864 }
2865 _impl_.path_.InitDefault();
2866 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2867 _impl_.path_.Set("", GetArenaForAllocation());
2868 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2869 if (from._internal_has_path()) {
2870 _this->_impl_.path_.Set(from._internal_path(),
2871 _this->GetArenaForAllocation());
2872 }
2873 ::memcpy(&_impl_.root_, &from._impl_.root_,
2874 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.level_) -
2875 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
2876 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupRenameFtraceEvent)
2877 }
2878
SharedCtor(::_pb::Arena * arena,bool is_message_owned)2879 inline void CgroupRenameFtraceEvent::SharedCtor(
2880 ::_pb::Arena* arena, bool is_message_owned) {
2881 (void)arena;
2882 (void)is_message_owned;
2883 new (&_impl_) Impl_{
2884 decltype(_impl_._has_bits_){}
2885 , /*decltype(_impl_._cached_size_)*/{}
2886 , decltype(_impl_.cname_){}
2887 , decltype(_impl_.path_){}
2888 , decltype(_impl_.root_){0}
2889 , decltype(_impl_.id_){0}
2890 , decltype(_impl_.level_){0}
2891 };
2892 _impl_.cname_.InitDefault();
2893 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2894 _impl_.cname_.Set("", GetArenaForAllocation());
2895 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2896 _impl_.path_.InitDefault();
2897 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2898 _impl_.path_.Set("", GetArenaForAllocation());
2899 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2900 }
2901
~CgroupRenameFtraceEvent()2902 CgroupRenameFtraceEvent::~CgroupRenameFtraceEvent() {
2903 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupRenameFtraceEvent)
2904 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
2905 (void)arena;
2906 return;
2907 }
2908 SharedDtor();
2909 }
2910
SharedDtor()2911 inline void CgroupRenameFtraceEvent::SharedDtor() {
2912 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
2913 _impl_.cname_.Destroy();
2914 _impl_.path_.Destroy();
2915 }
2916
SetCachedSize(int size) const2917 void CgroupRenameFtraceEvent::SetCachedSize(int size) const {
2918 _impl_._cached_size_.Set(size);
2919 }
2920
Clear()2921 void CgroupRenameFtraceEvent::Clear() {
2922 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupRenameFtraceEvent)
2923 ::uint32_t cached_has_bits = 0;
2924 // Prevent compiler warnings about cached_has_bits being unused
2925 (void) cached_has_bits;
2926
2927 cached_has_bits = _impl_._has_bits_[0];
2928 if (cached_has_bits & 0x00000003u) {
2929 if (cached_has_bits & 0x00000001u) {
2930 _impl_.cname_.ClearNonDefaultToEmpty();
2931 }
2932 if (cached_has_bits & 0x00000002u) {
2933 _impl_.path_.ClearNonDefaultToEmpty();
2934 }
2935 }
2936 if (cached_has_bits & 0x0000001cu) {
2937 ::memset(&_impl_.root_, 0, static_cast<size_t>(
2938 reinterpret_cast<char*>(&_impl_.level_) -
2939 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.level_));
2940 }
2941 _impl_._has_bits_.Clear();
2942 _internal_metadata_.Clear<std::string>();
2943 }
2944
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)2945 const char* CgroupRenameFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
2946 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
2947 _Internal::HasBits has_bits{};
2948 while (!ctx->Done(&ptr)) {
2949 ::uint32_t tag;
2950 ptr = ::_pbi::ReadTag(ptr, &tag);
2951 switch (tag >> 3) {
2952 // optional int32 root = 1;
2953 case 1:
2954 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
2955 _Internal::set_has_root(&has_bits);
2956 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2957 CHK_(ptr);
2958 } else {
2959 goto handle_unusual;
2960 }
2961 continue;
2962 // optional int32 id = 2;
2963 case 2:
2964 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
2965 _Internal::set_has_id(&has_bits);
2966 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2967 CHK_(ptr);
2968 } else {
2969 goto handle_unusual;
2970 }
2971 continue;
2972 // optional string cname = 3;
2973 case 3:
2974 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
2975 auto str = _internal_mutable_cname();
2976 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2977 CHK_(ptr);
2978 } else {
2979 goto handle_unusual;
2980 }
2981 continue;
2982 // optional int32 level = 4;
2983 case 4:
2984 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
2985 _Internal::set_has_level(&has_bits);
2986 _impl_.level_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
2987 CHK_(ptr);
2988 } else {
2989 goto handle_unusual;
2990 }
2991 continue;
2992 // optional string path = 5;
2993 case 5:
2994 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
2995 auto str = _internal_mutable_path();
2996 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
2997 CHK_(ptr);
2998 } else {
2999 goto handle_unusual;
3000 }
3001 continue;
3002 default:
3003 goto handle_unusual;
3004 } // switch
3005 handle_unusual:
3006 if ((tag == 0) || ((tag & 7) == 4)) {
3007 CHK_(ptr);
3008 ctx->SetLastTag(tag);
3009 goto message_done;
3010 }
3011 ptr = UnknownFieldParse(
3012 tag,
3013 _internal_metadata_.mutable_unknown_fields<std::string>(),
3014 ptr, ctx);
3015 CHK_(ptr != nullptr);
3016 } // while
3017 message_done:
3018 _impl_._has_bits_.Or(has_bits);
3019 return ptr;
3020 failure:
3021 ptr = nullptr;
3022 goto message_done;
3023 #undef CHK_
3024 }
3025
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3026 ::uint8_t* CgroupRenameFtraceEvent::_InternalSerialize(
3027 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3028 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupRenameFtraceEvent)
3029 ::uint32_t cached_has_bits = 0;
3030 (void) cached_has_bits;
3031
3032 cached_has_bits = _impl_._has_bits_[0];
3033 // optional int32 root = 1;
3034 if (cached_has_bits & 0x00000004u) {
3035 target = stream->EnsureSpace(target);
3036 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
3037 }
3038
3039 // optional int32 id = 2;
3040 if (cached_has_bits & 0x00000008u) {
3041 target = stream->EnsureSpace(target);
3042 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_id(), target);
3043 }
3044
3045 // optional string cname = 3;
3046 if (cached_has_bits & 0x00000001u) {
3047 target = stream->WriteStringMaybeAliased(
3048 3, this->_internal_cname(), target);
3049 }
3050
3051 // optional int32 level = 4;
3052 if (cached_has_bits & 0x00000010u) {
3053 target = stream->EnsureSpace(target);
3054 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_level(), target);
3055 }
3056
3057 // optional string path = 5;
3058 if (cached_has_bits & 0x00000002u) {
3059 target = stream->WriteStringMaybeAliased(
3060 5, this->_internal_path(), target);
3061 }
3062
3063 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3064 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3065 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3066 }
3067 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupRenameFtraceEvent)
3068 return target;
3069 }
3070
ByteSizeLong() const3071 size_t CgroupRenameFtraceEvent::ByteSizeLong() const {
3072 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupRenameFtraceEvent)
3073 size_t total_size = 0;
3074
3075 ::uint32_t cached_has_bits = 0;
3076 // Prevent compiler warnings about cached_has_bits being unused
3077 (void) cached_has_bits;
3078
3079 cached_has_bits = _impl_._has_bits_[0];
3080 if (cached_has_bits & 0x0000001fu) {
3081 // optional string cname = 3;
3082 if (cached_has_bits & 0x00000001u) {
3083 total_size += 1 +
3084 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3085 this->_internal_cname());
3086 }
3087
3088 // optional string path = 5;
3089 if (cached_has_bits & 0x00000002u) {
3090 total_size += 1 +
3091 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3092 this->_internal_path());
3093 }
3094
3095 // optional int32 root = 1;
3096 if (cached_has_bits & 0x00000004u) {
3097 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
3098 }
3099
3100 // optional int32 id = 2;
3101 if (cached_has_bits & 0x00000008u) {
3102 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
3103 }
3104
3105 // optional int32 level = 4;
3106 if (cached_has_bits & 0x00000010u) {
3107 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_level());
3108 }
3109
3110 }
3111 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3112 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3113 }
3114 int cached_size = ::_pbi::ToCachedSize(total_size);
3115 SetCachedSize(cached_size);
3116 return total_size;
3117 }
3118
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3119 void CgroupRenameFtraceEvent::CheckTypeAndMergeFrom(
3120 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3121 MergeFrom(*::_pbi::DownCast<const CgroupRenameFtraceEvent*>(
3122 &from));
3123 }
3124
MergeFrom(const CgroupRenameFtraceEvent & from)3125 void CgroupRenameFtraceEvent::MergeFrom(const CgroupRenameFtraceEvent& from) {
3126 CgroupRenameFtraceEvent* const _this = this;
3127 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupRenameFtraceEvent)
3128 GOOGLE_DCHECK_NE(&from, _this);
3129 ::uint32_t cached_has_bits = 0;
3130 (void) cached_has_bits;
3131
3132 cached_has_bits = from._impl_._has_bits_[0];
3133 if (cached_has_bits & 0x0000001fu) {
3134 if (cached_has_bits & 0x00000001u) {
3135 _this->_internal_set_cname(from._internal_cname());
3136 }
3137 if (cached_has_bits & 0x00000002u) {
3138 _this->_internal_set_path(from._internal_path());
3139 }
3140 if (cached_has_bits & 0x00000004u) {
3141 _this->_impl_.root_ = from._impl_.root_;
3142 }
3143 if (cached_has_bits & 0x00000008u) {
3144 _this->_impl_.id_ = from._impl_.id_;
3145 }
3146 if (cached_has_bits & 0x00000010u) {
3147 _this->_impl_.level_ = from._impl_.level_;
3148 }
3149 _this->_impl_._has_bits_[0] |= cached_has_bits;
3150 }
3151 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3152 }
3153
CopyFrom(const CgroupRenameFtraceEvent & from)3154 void CgroupRenameFtraceEvent::CopyFrom(const CgroupRenameFtraceEvent& from) {
3155 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupRenameFtraceEvent)
3156 if (&from == this) return;
3157 Clear();
3158 MergeFrom(from);
3159 }
3160
IsInitialized() const3161 bool CgroupRenameFtraceEvent::IsInitialized() const {
3162 return true;
3163 }
3164
InternalSwap(CgroupRenameFtraceEvent * other)3165 void CgroupRenameFtraceEvent::InternalSwap(CgroupRenameFtraceEvent* other) {
3166 using std::swap;
3167 auto* lhs_arena = GetArenaForAllocation();
3168 auto* rhs_arena = other->GetArenaForAllocation();
3169 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3170 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3171 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3172 &_impl_.cname_, lhs_arena,
3173 &other->_impl_.cname_, rhs_arena
3174 );
3175 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3176 &_impl_.path_, lhs_arena,
3177 &other->_impl_.path_, rhs_arena
3178 );
3179 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3180 PROTOBUF_FIELD_OFFSET(CgroupRenameFtraceEvent, _impl_.level_)
3181 + sizeof(CgroupRenameFtraceEvent::_impl_.level_) // NOLINT
3182 - PROTOBUF_FIELD_OFFSET(CgroupRenameFtraceEvent, _impl_.root_)>(
3183 reinterpret_cast<char*>(&_impl_.root_),
3184 reinterpret_cast<char*>(&other->_impl_.root_));
3185 }
3186
GetTypeName() const3187 std::string CgroupRenameFtraceEvent::GetTypeName() const {
3188 return "perfetto.protos.CgroupRenameFtraceEvent";
3189 }
3190
3191
3192 // ===================================================================
3193
3194 class CgroupSetupRootFtraceEvent::_Internal {
3195 public:
3196 using HasBits = decltype(std::declval<CgroupSetupRootFtraceEvent>()._impl_._has_bits_);
set_has_root(HasBits * has_bits)3197 static void set_has_root(HasBits* has_bits) {
3198 (*has_bits)[0] |= 2u;
3199 }
set_has_ss_mask(HasBits * has_bits)3200 static void set_has_ss_mask(HasBits* has_bits) {
3201 (*has_bits)[0] |= 4u;
3202 }
set_has_name(HasBits * has_bits)3203 static void set_has_name(HasBits* has_bits) {
3204 (*has_bits)[0] |= 1u;
3205 }
3206 };
3207
CgroupSetupRootFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)3208 CgroupSetupRootFtraceEvent::CgroupSetupRootFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
3209 bool is_message_owned)
3210 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
3211 SharedCtor(arena, is_message_owned);
3212 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CgroupSetupRootFtraceEvent)
3213 }
CgroupSetupRootFtraceEvent(const CgroupSetupRootFtraceEvent & from)3214 CgroupSetupRootFtraceEvent::CgroupSetupRootFtraceEvent(const CgroupSetupRootFtraceEvent& from)
3215 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
3216 CgroupSetupRootFtraceEvent* const _this = this; (void)_this;
3217 new (&_impl_) Impl_{
3218 decltype(_impl_._has_bits_){from._impl_._has_bits_}
3219 , /*decltype(_impl_._cached_size_)*/{}
3220 , decltype(_impl_.name_){}
3221 , decltype(_impl_.root_){}
3222 , decltype(_impl_.ss_mask_){}};
3223
3224 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3225 _impl_.name_.InitDefault();
3226 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3227 _impl_.name_.Set("", GetArenaForAllocation());
3228 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3229 if (from._internal_has_name()) {
3230 _this->_impl_.name_.Set(from._internal_name(),
3231 _this->GetArenaForAllocation());
3232 }
3233 ::memcpy(&_impl_.root_, &from._impl_.root_,
3234 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.ss_mask_) -
3235 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.ss_mask_));
3236 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CgroupSetupRootFtraceEvent)
3237 }
3238
SharedCtor(::_pb::Arena * arena,bool is_message_owned)3239 inline void CgroupSetupRootFtraceEvent::SharedCtor(
3240 ::_pb::Arena* arena, bool is_message_owned) {
3241 (void)arena;
3242 (void)is_message_owned;
3243 new (&_impl_) Impl_{
3244 decltype(_impl_._has_bits_){}
3245 , /*decltype(_impl_._cached_size_)*/{}
3246 , decltype(_impl_.name_){}
3247 , decltype(_impl_.root_){0}
3248 , decltype(_impl_.ss_mask_){0u}
3249 };
3250 _impl_.name_.InitDefault();
3251 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3252 _impl_.name_.Set("", GetArenaForAllocation());
3253 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3254 }
3255
~CgroupSetupRootFtraceEvent()3256 CgroupSetupRootFtraceEvent::~CgroupSetupRootFtraceEvent() {
3257 // @@protoc_insertion_point(destructor:perfetto.protos.CgroupSetupRootFtraceEvent)
3258 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
3259 (void)arena;
3260 return;
3261 }
3262 SharedDtor();
3263 }
3264
SharedDtor()3265 inline void CgroupSetupRootFtraceEvent::SharedDtor() {
3266 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
3267 _impl_.name_.Destroy();
3268 }
3269
SetCachedSize(int size) const3270 void CgroupSetupRootFtraceEvent::SetCachedSize(int size) const {
3271 _impl_._cached_size_.Set(size);
3272 }
3273
Clear()3274 void CgroupSetupRootFtraceEvent::Clear() {
3275 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CgroupSetupRootFtraceEvent)
3276 ::uint32_t cached_has_bits = 0;
3277 // Prevent compiler warnings about cached_has_bits being unused
3278 (void) cached_has_bits;
3279
3280 cached_has_bits = _impl_._has_bits_[0];
3281 if (cached_has_bits & 0x00000001u) {
3282 _impl_.name_.ClearNonDefaultToEmpty();
3283 }
3284 if (cached_has_bits & 0x00000006u) {
3285 ::memset(&_impl_.root_, 0, static_cast<size_t>(
3286 reinterpret_cast<char*>(&_impl_.ss_mask_) -
3287 reinterpret_cast<char*>(&_impl_.root_)) + sizeof(_impl_.ss_mask_));
3288 }
3289 _impl_._has_bits_.Clear();
3290 _internal_metadata_.Clear<std::string>();
3291 }
3292
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)3293 const char* CgroupSetupRootFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
3294 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
3295 _Internal::HasBits has_bits{};
3296 while (!ctx->Done(&ptr)) {
3297 ::uint32_t tag;
3298 ptr = ::_pbi::ReadTag(ptr, &tag);
3299 switch (tag >> 3) {
3300 // optional int32 root = 1;
3301 case 1:
3302 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
3303 _Internal::set_has_root(&has_bits);
3304 _impl_.root_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3305 CHK_(ptr);
3306 } else {
3307 goto handle_unusual;
3308 }
3309 continue;
3310 // optional uint32 ss_mask = 2;
3311 case 2:
3312 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
3313 _Internal::set_has_ss_mask(&has_bits);
3314 _impl_.ss_mask_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
3315 CHK_(ptr);
3316 } else {
3317 goto handle_unusual;
3318 }
3319 continue;
3320 // optional string name = 3;
3321 case 3:
3322 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
3323 auto str = _internal_mutable_name();
3324 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
3325 CHK_(ptr);
3326 } else {
3327 goto handle_unusual;
3328 }
3329 continue;
3330 default:
3331 goto handle_unusual;
3332 } // switch
3333 handle_unusual:
3334 if ((tag == 0) || ((tag & 7) == 4)) {
3335 CHK_(ptr);
3336 ctx->SetLastTag(tag);
3337 goto message_done;
3338 }
3339 ptr = UnknownFieldParse(
3340 tag,
3341 _internal_metadata_.mutable_unknown_fields<std::string>(),
3342 ptr, ctx);
3343 CHK_(ptr != nullptr);
3344 } // while
3345 message_done:
3346 _impl_._has_bits_.Or(has_bits);
3347 return ptr;
3348 failure:
3349 ptr = nullptr;
3350 goto message_done;
3351 #undef CHK_
3352 }
3353
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const3354 ::uint8_t* CgroupSetupRootFtraceEvent::_InternalSerialize(
3355 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
3356 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CgroupSetupRootFtraceEvent)
3357 ::uint32_t cached_has_bits = 0;
3358 (void) cached_has_bits;
3359
3360 cached_has_bits = _impl_._has_bits_[0];
3361 // optional int32 root = 1;
3362 if (cached_has_bits & 0x00000002u) {
3363 target = stream->EnsureSpace(target);
3364 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_root(), target);
3365 }
3366
3367 // optional uint32 ss_mask = 2;
3368 if (cached_has_bits & 0x00000004u) {
3369 target = stream->EnsureSpace(target);
3370 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_ss_mask(), target);
3371 }
3372
3373 // optional string name = 3;
3374 if (cached_has_bits & 0x00000001u) {
3375 target = stream->WriteStringMaybeAliased(
3376 3, this->_internal_name(), target);
3377 }
3378
3379 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3380 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
3381 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
3382 }
3383 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CgroupSetupRootFtraceEvent)
3384 return target;
3385 }
3386
ByteSizeLong() const3387 size_t CgroupSetupRootFtraceEvent::ByteSizeLong() const {
3388 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CgroupSetupRootFtraceEvent)
3389 size_t total_size = 0;
3390
3391 ::uint32_t cached_has_bits = 0;
3392 // Prevent compiler warnings about cached_has_bits being unused
3393 (void) cached_has_bits;
3394
3395 cached_has_bits = _impl_._has_bits_[0];
3396 if (cached_has_bits & 0x00000007u) {
3397 // optional string name = 3;
3398 if (cached_has_bits & 0x00000001u) {
3399 total_size += 1 +
3400 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
3401 this->_internal_name());
3402 }
3403
3404 // optional int32 root = 1;
3405 if (cached_has_bits & 0x00000002u) {
3406 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_root());
3407 }
3408
3409 // optional uint32 ss_mask = 2;
3410 if (cached_has_bits & 0x00000004u) {
3411 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_ss_mask());
3412 }
3413
3414 }
3415 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
3416 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
3417 }
3418 int cached_size = ::_pbi::ToCachedSize(total_size);
3419 SetCachedSize(cached_size);
3420 return total_size;
3421 }
3422
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)3423 void CgroupSetupRootFtraceEvent::CheckTypeAndMergeFrom(
3424 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
3425 MergeFrom(*::_pbi::DownCast<const CgroupSetupRootFtraceEvent*>(
3426 &from));
3427 }
3428
MergeFrom(const CgroupSetupRootFtraceEvent & from)3429 void CgroupSetupRootFtraceEvent::MergeFrom(const CgroupSetupRootFtraceEvent& from) {
3430 CgroupSetupRootFtraceEvent* const _this = this;
3431 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CgroupSetupRootFtraceEvent)
3432 GOOGLE_DCHECK_NE(&from, _this);
3433 ::uint32_t cached_has_bits = 0;
3434 (void) cached_has_bits;
3435
3436 cached_has_bits = from._impl_._has_bits_[0];
3437 if (cached_has_bits & 0x00000007u) {
3438 if (cached_has_bits & 0x00000001u) {
3439 _this->_internal_set_name(from._internal_name());
3440 }
3441 if (cached_has_bits & 0x00000002u) {
3442 _this->_impl_.root_ = from._impl_.root_;
3443 }
3444 if (cached_has_bits & 0x00000004u) {
3445 _this->_impl_.ss_mask_ = from._impl_.ss_mask_;
3446 }
3447 _this->_impl_._has_bits_[0] |= cached_has_bits;
3448 }
3449 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
3450 }
3451
CopyFrom(const CgroupSetupRootFtraceEvent & from)3452 void CgroupSetupRootFtraceEvent::CopyFrom(const CgroupSetupRootFtraceEvent& from) {
3453 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CgroupSetupRootFtraceEvent)
3454 if (&from == this) return;
3455 Clear();
3456 MergeFrom(from);
3457 }
3458
IsInitialized() const3459 bool CgroupSetupRootFtraceEvent::IsInitialized() const {
3460 return true;
3461 }
3462
InternalSwap(CgroupSetupRootFtraceEvent * other)3463 void CgroupSetupRootFtraceEvent::InternalSwap(CgroupSetupRootFtraceEvent* other) {
3464 using std::swap;
3465 auto* lhs_arena = GetArenaForAllocation();
3466 auto* rhs_arena = other->GetArenaForAllocation();
3467 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
3468 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
3469 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
3470 &_impl_.name_, lhs_arena,
3471 &other->_impl_.name_, rhs_arena
3472 );
3473 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
3474 PROTOBUF_FIELD_OFFSET(CgroupSetupRootFtraceEvent, _impl_.ss_mask_)
3475 + sizeof(CgroupSetupRootFtraceEvent::_impl_.ss_mask_) // NOLINT
3476 - PROTOBUF_FIELD_OFFSET(CgroupSetupRootFtraceEvent, _impl_.root_)>(
3477 reinterpret_cast<char*>(&_impl_.root_),
3478 reinterpret_cast<char*>(&other->_impl_.root_));
3479 }
3480
GetTypeName() const3481 std::string CgroupSetupRootFtraceEvent::GetTypeName() const {
3482 return "perfetto.protos.CgroupSetupRootFtraceEvent";
3483 }
3484
3485
3486 // @@protoc_insertion_point(namespace_scope)
3487 } // namespace protos
3488 } // namespace perfetto
3489 PROTOBUF_NAMESPACE_OPEN
3490 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupAttachTaskFtraceEvent*
CreateMaybeMessage(Arena * arena)3491 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupAttachTaskFtraceEvent >(Arena* arena) {
3492 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupAttachTaskFtraceEvent >(arena);
3493 }
3494 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupMkdirFtraceEvent*
CreateMaybeMessage(Arena * arena)3495 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupMkdirFtraceEvent >(Arena* arena) {
3496 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupMkdirFtraceEvent >(arena);
3497 }
3498 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupRemountFtraceEvent*
CreateMaybeMessage(Arena * arena)3499 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupRemountFtraceEvent >(Arena* arena) {
3500 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupRemountFtraceEvent >(arena);
3501 }
3502 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupRmdirFtraceEvent*
CreateMaybeMessage(Arena * arena)3503 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupRmdirFtraceEvent >(Arena* arena) {
3504 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupRmdirFtraceEvent >(arena);
3505 }
3506 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupTransferTasksFtraceEvent*
CreateMaybeMessage(Arena * arena)3507 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupTransferTasksFtraceEvent >(Arena* arena) {
3508 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupTransferTasksFtraceEvent >(arena);
3509 }
3510 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupDestroyRootFtraceEvent*
CreateMaybeMessage(Arena * arena)3511 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupDestroyRootFtraceEvent >(Arena* arena) {
3512 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupDestroyRootFtraceEvent >(arena);
3513 }
3514 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupReleaseFtraceEvent*
CreateMaybeMessage(Arena * arena)3515 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupReleaseFtraceEvent >(Arena* arena) {
3516 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupReleaseFtraceEvent >(arena);
3517 }
3518 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupRenameFtraceEvent*
CreateMaybeMessage(Arena * arena)3519 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupRenameFtraceEvent >(Arena* arena) {
3520 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupRenameFtraceEvent >(arena);
3521 }
3522 template<> PROTOBUF_NOINLINE ::perfetto::protos::CgroupSetupRootFtraceEvent*
CreateMaybeMessage(Arena * arena)3523 Arena::CreateMaybeMessage< ::perfetto::protos::CgroupSetupRootFtraceEvent >(Arena* arena) {
3524 return Arena::CreateMessageInternal< ::perfetto::protos::CgroupSetupRootFtraceEvent >(arena);
3525 }
3526 PROTOBUF_NAMESPACE_CLOSE
3527
3528 // @@protoc_insertion_point(global_scope)
3529 #include <google/protobuf/port_undef.inc>
3530