1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/android_fs.proto
3
4 #include "protos/perfetto/trace/ftrace/android_fs.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 {
AndroidFsDatareadEndFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR AndroidFsDatareadEndFtraceEvent::AndroidFsDatareadEndFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.ino_)*/::uint64_t{0u}
28 , /*decltype(_impl_.offset_)*/::int64_t{0}
29 , /*decltype(_impl_.bytes_)*/0} {}
30 struct AndroidFsDatareadEndFtraceEventDefaultTypeInternal {
AndroidFsDatareadEndFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatareadEndFtraceEventDefaultTypeInternal31 PROTOBUF_CONSTEXPR AndroidFsDatareadEndFtraceEventDefaultTypeInternal()
32 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidFsDatareadEndFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatareadEndFtraceEventDefaultTypeInternal33 ~AndroidFsDatareadEndFtraceEventDefaultTypeInternal() {}
34 union { // NOLINT(misc-non-private-member-variables-in-classes)
35 AndroidFsDatareadEndFtraceEvent _instance;
36 };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidFsDatareadEndFtraceEventDefaultTypeInternal _AndroidFsDatareadEndFtraceEvent_default_instance_;
AndroidFsDatareadStartFtraceEvent(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR AndroidFsDatareadStartFtraceEvent::AndroidFsDatareadStartFtraceEvent(
40 ::_pbi::ConstantInitialized): _impl_{
41 /*decltype(_impl_._has_bits_)*/{}
42 , /*decltype(_impl_._cached_size_)*/{}
43 , /*decltype(_impl_.cmdline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
44 , /*decltype(_impl_.pathbuf_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
45 , /*decltype(_impl_.i_size_)*/::int64_t{0}
46 , /*decltype(_impl_.ino_)*/::uint64_t{0u}
47 , /*decltype(_impl_.bytes_)*/0
48 , /*decltype(_impl_.pid_)*/0
49 , /*decltype(_impl_.offset_)*/::int64_t{0}} {}
50 struct AndroidFsDatareadStartFtraceEventDefaultTypeInternal {
AndroidFsDatareadStartFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatareadStartFtraceEventDefaultTypeInternal51 PROTOBUF_CONSTEXPR AndroidFsDatareadStartFtraceEventDefaultTypeInternal()
52 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidFsDatareadStartFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatareadStartFtraceEventDefaultTypeInternal53 ~AndroidFsDatareadStartFtraceEventDefaultTypeInternal() {}
54 union { // NOLINT(misc-non-private-member-variables-in-classes)
55 AndroidFsDatareadStartFtraceEvent _instance;
56 };
57 };
58 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidFsDatareadStartFtraceEventDefaultTypeInternal _AndroidFsDatareadStartFtraceEvent_default_instance_;
AndroidFsDatawriteEndFtraceEvent(::_pbi::ConstantInitialized)59 PROTOBUF_CONSTEXPR AndroidFsDatawriteEndFtraceEvent::AndroidFsDatawriteEndFtraceEvent(
60 ::_pbi::ConstantInitialized): _impl_{
61 /*decltype(_impl_._has_bits_)*/{}
62 , /*decltype(_impl_._cached_size_)*/{}
63 , /*decltype(_impl_.ino_)*/::uint64_t{0u}
64 , /*decltype(_impl_.offset_)*/::int64_t{0}
65 , /*decltype(_impl_.bytes_)*/0} {}
66 struct AndroidFsDatawriteEndFtraceEventDefaultTypeInternal {
AndroidFsDatawriteEndFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatawriteEndFtraceEventDefaultTypeInternal67 PROTOBUF_CONSTEXPR AndroidFsDatawriteEndFtraceEventDefaultTypeInternal()
68 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidFsDatawriteEndFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatawriteEndFtraceEventDefaultTypeInternal69 ~AndroidFsDatawriteEndFtraceEventDefaultTypeInternal() {}
70 union { // NOLINT(misc-non-private-member-variables-in-classes)
71 AndroidFsDatawriteEndFtraceEvent _instance;
72 };
73 };
74 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidFsDatawriteEndFtraceEventDefaultTypeInternal _AndroidFsDatawriteEndFtraceEvent_default_instance_;
AndroidFsDatawriteStartFtraceEvent(::_pbi::ConstantInitialized)75 PROTOBUF_CONSTEXPR AndroidFsDatawriteStartFtraceEvent::AndroidFsDatawriteStartFtraceEvent(
76 ::_pbi::ConstantInitialized): _impl_{
77 /*decltype(_impl_._has_bits_)*/{}
78 , /*decltype(_impl_._cached_size_)*/{}
79 , /*decltype(_impl_.cmdline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
80 , /*decltype(_impl_.pathbuf_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
81 , /*decltype(_impl_.i_size_)*/::int64_t{0}
82 , /*decltype(_impl_.ino_)*/::uint64_t{0u}
83 , /*decltype(_impl_.bytes_)*/0
84 , /*decltype(_impl_.pid_)*/0
85 , /*decltype(_impl_.offset_)*/::int64_t{0}} {}
86 struct AndroidFsDatawriteStartFtraceEventDefaultTypeInternal {
AndroidFsDatawriteStartFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatawriteStartFtraceEventDefaultTypeInternal87 PROTOBUF_CONSTEXPR AndroidFsDatawriteStartFtraceEventDefaultTypeInternal()
88 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidFsDatawriteStartFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsDatawriteStartFtraceEventDefaultTypeInternal89 ~AndroidFsDatawriteStartFtraceEventDefaultTypeInternal() {}
90 union { // NOLINT(misc-non-private-member-variables-in-classes)
91 AndroidFsDatawriteStartFtraceEvent _instance;
92 };
93 };
94 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidFsDatawriteStartFtraceEventDefaultTypeInternal _AndroidFsDatawriteStartFtraceEvent_default_instance_;
AndroidFsFsyncEndFtraceEvent(::_pbi::ConstantInitialized)95 PROTOBUF_CONSTEXPR AndroidFsFsyncEndFtraceEvent::AndroidFsFsyncEndFtraceEvent(
96 ::_pbi::ConstantInitialized): _impl_{
97 /*decltype(_impl_._has_bits_)*/{}
98 , /*decltype(_impl_._cached_size_)*/{}
99 , /*decltype(_impl_.ino_)*/::uint64_t{0u}
100 , /*decltype(_impl_.offset_)*/::int64_t{0}
101 , /*decltype(_impl_.bytes_)*/0} {}
102 struct AndroidFsFsyncEndFtraceEventDefaultTypeInternal {
AndroidFsFsyncEndFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsFsyncEndFtraceEventDefaultTypeInternal103 PROTOBUF_CONSTEXPR AndroidFsFsyncEndFtraceEventDefaultTypeInternal()
104 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidFsFsyncEndFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsFsyncEndFtraceEventDefaultTypeInternal105 ~AndroidFsFsyncEndFtraceEventDefaultTypeInternal() {}
106 union { // NOLINT(misc-non-private-member-variables-in-classes)
107 AndroidFsFsyncEndFtraceEvent _instance;
108 };
109 };
110 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidFsFsyncEndFtraceEventDefaultTypeInternal _AndroidFsFsyncEndFtraceEvent_default_instance_;
AndroidFsFsyncStartFtraceEvent(::_pbi::ConstantInitialized)111 PROTOBUF_CONSTEXPR AndroidFsFsyncStartFtraceEvent::AndroidFsFsyncStartFtraceEvent(
112 ::_pbi::ConstantInitialized): _impl_{
113 /*decltype(_impl_._has_bits_)*/{}
114 , /*decltype(_impl_._cached_size_)*/{}
115 , /*decltype(_impl_.cmdline_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
116 , /*decltype(_impl_.pathbuf_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
117 , /*decltype(_impl_.i_size_)*/::int64_t{0}
118 , /*decltype(_impl_.ino_)*/::uint64_t{0u}
119 , /*decltype(_impl_.pid_)*/0} {}
120 struct AndroidFsFsyncStartFtraceEventDefaultTypeInternal {
AndroidFsFsyncStartFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsFsyncStartFtraceEventDefaultTypeInternal121 PROTOBUF_CONSTEXPR AndroidFsFsyncStartFtraceEventDefaultTypeInternal()
122 : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidFsFsyncStartFtraceEventDefaultTypeInternalperfetto::protos::AndroidFsFsyncStartFtraceEventDefaultTypeInternal123 ~AndroidFsFsyncStartFtraceEventDefaultTypeInternal() {}
124 union { // NOLINT(misc-non-private-member-variables-in-classes)
125 AndroidFsFsyncStartFtraceEvent _instance;
126 };
127 };
128 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidFsFsyncStartFtraceEventDefaultTypeInternal _AndroidFsFsyncStartFtraceEvent_default_instance_;
129 } // namespace protos
130 } // namespace perfetto
131 namespace perfetto {
132 namespace protos {
133
134 // ===================================================================
135
136 class AndroidFsDatareadEndFtraceEvent::_Internal {
137 public:
138 using HasBits = decltype(std::declval<AndroidFsDatareadEndFtraceEvent>()._impl_._has_bits_);
set_has_bytes(HasBits * has_bits)139 static void set_has_bytes(HasBits* has_bits) {
140 (*has_bits)[0] |= 4u;
141 }
set_has_ino(HasBits * has_bits)142 static void set_has_ino(HasBits* has_bits) {
143 (*has_bits)[0] |= 1u;
144 }
set_has_offset(HasBits * has_bits)145 static void set_has_offset(HasBits* has_bits) {
146 (*has_bits)[0] |= 2u;
147 }
148 };
149
AndroidFsDatareadEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)150 AndroidFsDatareadEndFtraceEvent::AndroidFsDatareadEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
151 bool is_message_owned)
152 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
153 SharedCtor(arena, is_message_owned);
154 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
155 }
AndroidFsDatareadEndFtraceEvent(const AndroidFsDatareadEndFtraceEvent & from)156 AndroidFsDatareadEndFtraceEvent::AndroidFsDatareadEndFtraceEvent(const AndroidFsDatareadEndFtraceEvent& from)
157 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
158 AndroidFsDatareadEndFtraceEvent* const _this = this; (void)_this;
159 new (&_impl_) Impl_{
160 decltype(_impl_._has_bits_){from._impl_._has_bits_}
161 , /*decltype(_impl_._cached_size_)*/{}
162 , decltype(_impl_.ino_){}
163 , decltype(_impl_.offset_){}
164 , decltype(_impl_.bytes_){}};
165
166 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
167 ::memcpy(&_impl_.ino_, &from._impl_.ino_,
168 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bytes_) -
169 reinterpret_cast<char*>(&_impl_.ino_)) + sizeof(_impl_.bytes_));
170 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
171 }
172
SharedCtor(::_pb::Arena * arena,bool is_message_owned)173 inline void AndroidFsDatareadEndFtraceEvent::SharedCtor(
174 ::_pb::Arena* arena, bool is_message_owned) {
175 (void)arena;
176 (void)is_message_owned;
177 new (&_impl_) Impl_{
178 decltype(_impl_._has_bits_){}
179 , /*decltype(_impl_._cached_size_)*/{}
180 , decltype(_impl_.ino_){::uint64_t{0u}}
181 , decltype(_impl_.offset_){::int64_t{0}}
182 , decltype(_impl_.bytes_){0}
183 };
184 }
185
~AndroidFsDatareadEndFtraceEvent()186 AndroidFsDatareadEndFtraceEvent::~AndroidFsDatareadEndFtraceEvent() {
187 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
188 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
189 (void)arena;
190 return;
191 }
192 SharedDtor();
193 }
194
SharedDtor()195 inline void AndroidFsDatareadEndFtraceEvent::SharedDtor() {
196 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
197 }
198
SetCachedSize(int size) const199 void AndroidFsDatareadEndFtraceEvent::SetCachedSize(int size) const {
200 _impl_._cached_size_.Set(size);
201 }
202
Clear()203 void AndroidFsDatareadEndFtraceEvent::Clear() {
204 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
205 ::uint32_t cached_has_bits = 0;
206 // Prevent compiler warnings about cached_has_bits being unused
207 (void) cached_has_bits;
208
209 cached_has_bits = _impl_._has_bits_[0];
210 if (cached_has_bits & 0x00000007u) {
211 ::memset(&_impl_.ino_, 0, static_cast<size_t>(
212 reinterpret_cast<char*>(&_impl_.bytes_) -
213 reinterpret_cast<char*>(&_impl_.ino_)) + sizeof(_impl_.bytes_));
214 }
215 _impl_._has_bits_.Clear();
216 _internal_metadata_.Clear<std::string>();
217 }
218
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)219 const char* AndroidFsDatareadEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
220 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
221 _Internal::HasBits has_bits{};
222 while (!ctx->Done(&ptr)) {
223 ::uint32_t tag;
224 ptr = ::_pbi::ReadTag(ptr, &tag);
225 switch (tag >> 3) {
226 // optional int32 bytes = 1;
227 case 1:
228 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
229 _Internal::set_has_bytes(&has_bits);
230 _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
231 CHK_(ptr);
232 } else {
233 goto handle_unusual;
234 }
235 continue;
236 // optional uint64 ino = 2;
237 case 2:
238 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
239 _Internal::set_has_ino(&has_bits);
240 _impl_.ino_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
241 CHK_(ptr);
242 } else {
243 goto handle_unusual;
244 }
245 continue;
246 // optional int64 offset = 3;
247 case 3:
248 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
249 _Internal::set_has_offset(&has_bits);
250 _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
251 CHK_(ptr);
252 } else {
253 goto handle_unusual;
254 }
255 continue;
256 default:
257 goto handle_unusual;
258 } // switch
259 handle_unusual:
260 if ((tag == 0) || ((tag & 7) == 4)) {
261 CHK_(ptr);
262 ctx->SetLastTag(tag);
263 goto message_done;
264 }
265 ptr = UnknownFieldParse(
266 tag,
267 _internal_metadata_.mutable_unknown_fields<std::string>(),
268 ptr, ctx);
269 CHK_(ptr != nullptr);
270 } // while
271 message_done:
272 _impl_._has_bits_.Or(has_bits);
273 return ptr;
274 failure:
275 ptr = nullptr;
276 goto message_done;
277 #undef CHK_
278 }
279
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const280 ::uint8_t* AndroidFsDatareadEndFtraceEvent::_InternalSerialize(
281 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
282 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
283 ::uint32_t cached_has_bits = 0;
284 (void) cached_has_bits;
285
286 cached_has_bits = _impl_._has_bits_[0];
287 // optional int32 bytes = 1;
288 if (cached_has_bits & 0x00000004u) {
289 target = stream->EnsureSpace(target);
290 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_bytes(), target);
291 }
292
293 // optional uint64 ino = 2;
294 if (cached_has_bits & 0x00000001u) {
295 target = stream->EnsureSpace(target);
296 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ino(), target);
297 }
298
299 // optional int64 offset = 3;
300 if (cached_has_bits & 0x00000002u) {
301 target = stream->EnsureSpace(target);
302 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target);
303 }
304
305 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
306 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
307 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
308 }
309 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
310 return target;
311 }
312
ByteSizeLong() const313 size_t AndroidFsDatareadEndFtraceEvent::ByteSizeLong() const {
314 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
315 size_t total_size = 0;
316
317 ::uint32_t cached_has_bits = 0;
318 // Prevent compiler warnings about cached_has_bits being unused
319 (void) cached_has_bits;
320
321 cached_has_bits = _impl_._has_bits_[0];
322 if (cached_has_bits & 0x00000007u) {
323 // optional uint64 ino = 2;
324 if (cached_has_bits & 0x00000001u) {
325 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ino());
326 }
327
328 // optional int64 offset = 3;
329 if (cached_has_bits & 0x00000002u) {
330 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
331 }
332
333 // optional int32 bytes = 1;
334 if (cached_has_bits & 0x00000004u) {
335 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bytes());
336 }
337
338 }
339 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
340 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
341 }
342 int cached_size = ::_pbi::ToCachedSize(total_size);
343 SetCachedSize(cached_size);
344 return total_size;
345 }
346
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)347 void AndroidFsDatareadEndFtraceEvent::CheckTypeAndMergeFrom(
348 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
349 MergeFrom(*::_pbi::DownCast<const AndroidFsDatareadEndFtraceEvent*>(
350 &from));
351 }
352
MergeFrom(const AndroidFsDatareadEndFtraceEvent & from)353 void AndroidFsDatareadEndFtraceEvent::MergeFrom(const AndroidFsDatareadEndFtraceEvent& from) {
354 AndroidFsDatareadEndFtraceEvent* const _this = this;
355 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
356 GOOGLE_DCHECK_NE(&from, _this);
357 ::uint32_t cached_has_bits = 0;
358 (void) cached_has_bits;
359
360 cached_has_bits = from._impl_._has_bits_[0];
361 if (cached_has_bits & 0x00000007u) {
362 if (cached_has_bits & 0x00000001u) {
363 _this->_impl_.ino_ = from._impl_.ino_;
364 }
365 if (cached_has_bits & 0x00000002u) {
366 _this->_impl_.offset_ = from._impl_.offset_;
367 }
368 if (cached_has_bits & 0x00000004u) {
369 _this->_impl_.bytes_ = from._impl_.bytes_;
370 }
371 _this->_impl_._has_bits_[0] |= cached_has_bits;
372 }
373 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
374 }
375
CopyFrom(const AndroidFsDatareadEndFtraceEvent & from)376 void AndroidFsDatareadEndFtraceEvent::CopyFrom(const AndroidFsDatareadEndFtraceEvent& from) {
377 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidFsDatareadEndFtraceEvent)
378 if (&from == this) return;
379 Clear();
380 MergeFrom(from);
381 }
382
IsInitialized() const383 bool AndroidFsDatareadEndFtraceEvent::IsInitialized() const {
384 return true;
385 }
386
InternalSwap(AndroidFsDatareadEndFtraceEvent * other)387 void AndroidFsDatareadEndFtraceEvent::InternalSwap(AndroidFsDatareadEndFtraceEvent* other) {
388 using std::swap;
389 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
390 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
391 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
392 PROTOBUF_FIELD_OFFSET(AndroidFsDatareadEndFtraceEvent, _impl_.bytes_)
393 + sizeof(AndroidFsDatareadEndFtraceEvent::_impl_.bytes_) // NOLINT
394 - PROTOBUF_FIELD_OFFSET(AndroidFsDatareadEndFtraceEvent, _impl_.ino_)>(
395 reinterpret_cast<char*>(&_impl_.ino_),
396 reinterpret_cast<char*>(&other->_impl_.ino_));
397 }
398
GetTypeName() const399 std::string AndroidFsDatareadEndFtraceEvent::GetTypeName() const {
400 return "perfetto.protos.AndroidFsDatareadEndFtraceEvent";
401 }
402
403
404 // ===================================================================
405
406 class AndroidFsDatareadStartFtraceEvent::_Internal {
407 public:
408 using HasBits = decltype(std::declval<AndroidFsDatareadStartFtraceEvent>()._impl_._has_bits_);
set_has_bytes(HasBits * has_bits)409 static void set_has_bytes(HasBits* has_bits) {
410 (*has_bits)[0] |= 16u;
411 }
set_has_cmdline(HasBits * has_bits)412 static void set_has_cmdline(HasBits* has_bits) {
413 (*has_bits)[0] |= 1u;
414 }
set_has_i_size(HasBits * has_bits)415 static void set_has_i_size(HasBits* has_bits) {
416 (*has_bits)[0] |= 4u;
417 }
set_has_ino(HasBits * has_bits)418 static void set_has_ino(HasBits* has_bits) {
419 (*has_bits)[0] |= 8u;
420 }
set_has_offset(HasBits * has_bits)421 static void set_has_offset(HasBits* has_bits) {
422 (*has_bits)[0] |= 64u;
423 }
set_has_pathbuf(HasBits * has_bits)424 static void set_has_pathbuf(HasBits* has_bits) {
425 (*has_bits)[0] |= 2u;
426 }
set_has_pid(HasBits * has_bits)427 static void set_has_pid(HasBits* has_bits) {
428 (*has_bits)[0] |= 32u;
429 }
430 };
431
AndroidFsDatareadStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)432 AndroidFsDatareadStartFtraceEvent::AndroidFsDatareadStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
433 bool is_message_owned)
434 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
435 SharedCtor(arena, is_message_owned);
436 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
437 }
AndroidFsDatareadStartFtraceEvent(const AndroidFsDatareadStartFtraceEvent & from)438 AndroidFsDatareadStartFtraceEvent::AndroidFsDatareadStartFtraceEvent(const AndroidFsDatareadStartFtraceEvent& from)
439 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
440 AndroidFsDatareadStartFtraceEvent* const _this = this; (void)_this;
441 new (&_impl_) Impl_{
442 decltype(_impl_._has_bits_){from._impl_._has_bits_}
443 , /*decltype(_impl_._cached_size_)*/{}
444 , decltype(_impl_.cmdline_){}
445 , decltype(_impl_.pathbuf_){}
446 , decltype(_impl_.i_size_){}
447 , decltype(_impl_.ino_){}
448 , decltype(_impl_.bytes_){}
449 , decltype(_impl_.pid_){}
450 , decltype(_impl_.offset_){}};
451
452 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
453 _impl_.cmdline_.InitDefault();
454 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
455 _impl_.cmdline_.Set("", GetArenaForAllocation());
456 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
457 if (from._internal_has_cmdline()) {
458 _this->_impl_.cmdline_.Set(from._internal_cmdline(),
459 _this->GetArenaForAllocation());
460 }
461 _impl_.pathbuf_.InitDefault();
462 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
463 _impl_.pathbuf_.Set("", GetArenaForAllocation());
464 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
465 if (from._internal_has_pathbuf()) {
466 _this->_impl_.pathbuf_.Set(from._internal_pathbuf(),
467 _this->GetArenaForAllocation());
468 }
469 ::memcpy(&_impl_.i_size_, &from._impl_.i_size_,
470 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.offset_) -
471 reinterpret_cast<char*>(&_impl_.i_size_)) + sizeof(_impl_.offset_));
472 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
473 }
474
SharedCtor(::_pb::Arena * arena,bool is_message_owned)475 inline void AndroidFsDatareadStartFtraceEvent::SharedCtor(
476 ::_pb::Arena* arena, bool is_message_owned) {
477 (void)arena;
478 (void)is_message_owned;
479 new (&_impl_) Impl_{
480 decltype(_impl_._has_bits_){}
481 , /*decltype(_impl_._cached_size_)*/{}
482 , decltype(_impl_.cmdline_){}
483 , decltype(_impl_.pathbuf_){}
484 , decltype(_impl_.i_size_){::int64_t{0}}
485 , decltype(_impl_.ino_){::uint64_t{0u}}
486 , decltype(_impl_.bytes_){0}
487 , decltype(_impl_.pid_){0}
488 , decltype(_impl_.offset_){::int64_t{0}}
489 };
490 _impl_.cmdline_.InitDefault();
491 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
492 _impl_.cmdline_.Set("", GetArenaForAllocation());
493 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
494 _impl_.pathbuf_.InitDefault();
495 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
496 _impl_.pathbuf_.Set("", GetArenaForAllocation());
497 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
498 }
499
~AndroidFsDatareadStartFtraceEvent()500 AndroidFsDatareadStartFtraceEvent::~AndroidFsDatareadStartFtraceEvent() {
501 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
502 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
503 (void)arena;
504 return;
505 }
506 SharedDtor();
507 }
508
SharedDtor()509 inline void AndroidFsDatareadStartFtraceEvent::SharedDtor() {
510 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
511 _impl_.cmdline_.Destroy();
512 _impl_.pathbuf_.Destroy();
513 }
514
SetCachedSize(int size) const515 void AndroidFsDatareadStartFtraceEvent::SetCachedSize(int size) const {
516 _impl_._cached_size_.Set(size);
517 }
518
Clear()519 void AndroidFsDatareadStartFtraceEvent::Clear() {
520 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
521 ::uint32_t cached_has_bits = 0;
522 // Prevent compiler warnings about cached_has_bits being unused
523 (void) cached_has_bits;
524
525 cached_has_bits = _impl_._has_bits_[0];
526 if (cached_has_bits & 0x00000003u) {
527 if (cached_has_bits & 0x00000001u) {
528 _impl_.cmdline_.ClearNonDefaultToEmpty();
529 }
530 if (cached_has_bits & 0x00000002u) {
531 _impl_.pathbuf_.ClearNonDefaultToEmpty();
532 }
533 }
534 if (cached_has_bits & 0x0000007cu) {
535 ::memset(&_impl_.i_size_, 0, static_cast<size_t>(
536 reinterpret_cast<char*>(&_impl_.offset_) -
537 reinterpret_cast<char*>(&_impl_.i_size_)) + sizeof(_impl_.offset_));
538 }
539 _impl_._has_bits_.Clear();
540 _internal_metadata_.Clear<std::string>();
541 }
542
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)543 const char* AndroidFsDatareadStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
544 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
545 _Internal::HasBits has_bits{};
546 while (!ctx->Done(&ptr)) {
547 ::uint32_t tag;
548 ptr = ::_pbi::ReadTag(ptr, &tag);
549 switch (tag >> 3) {
550 // optional int32 bytes = 1;
551 case 1:
552 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
553 _Internal::set_has_bytes(&has_bits);
554 _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
555 CHK_(ptr);
556 } else {
557 goto handle_unusual;
558 }
559 continue;
560 // optional string cmdline = 2;
561 case 2:
562 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
563 auto str = _internal_mutable_cmdline();
564 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
565 CHK_(ptr);
566 } else {
567 goto handle_unusual;
568 }
569 continue;
570 // optional int64 i_size = 3;
571 case 3:
572 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
573 _Internal::set_has_i_size(&has_bits);
574 _impl_.i_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
575 CHK_(ptr);
576 } else {
577 goto handle_unusual;
578 }
579 continue;
580 // optional uint64 ino = 4;
581 case 4:
582 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
583 _Internal::set_has_ino(&has_bits);
584 _impl_.ino_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
585 CHK_(ptr);
586 } else {
587 goto handle_unusual;
588 }
589 continue;
590 // optional int64 offset = 5;
591 case 5:
592 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
593 _Internal::set_has_offset(&has_bits);
594 _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
595 CHK_(ptr);
596 } else {
597 goto handle_unusual;
598 }
599 continue;
600 // optional string pathbuf = 6;
601 case 6:
602 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
603 auto str = _internal_mutable_pathbuf();
604 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
605 CHK_(ptr);
606 } else {
607 goto handle_unusual;
608 }
609 continue;
610 // optional int32 pid = 7;
611 case 7:
612 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
613 _Internal::set_has_pid(&has_bits);
614 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
615 CHK_(ptr);
616 } else {
617 goto handle_unusual;
618 }
619 continue;
620 default:
621 goto handle_unusual;
622 } // switch
623 handle_unusual:
624 if ((tag == 0) || ((tag & 7) == 4)) {
625 CHK_(ptr);
626 ctx->SetLastTag(tag);
627 goto message_done;
628 }
629 ptr = UnknownFieldParse(
630 tag,
631 _internal_metadata_.mutable_unknown_fields<std::string>(),
632 ptr, ctx);
633 CHK_(ptr != nullptr);
634 } // while
635 message_done:
636 _impl_._has_bits_.Or(has_bits);
637 return ptr;
638 failure:
639 ptr = nullptr;
640 goto message_done;
641 #undef CHK_
642 }
643
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const644 ::uint8_t* AndroidFsDatareadStartFtraceEvent::_InternalSerialize(
645 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
646 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
647 ::uint32_t cached_has_bits = 0;
648 (void) cached_has_bits;
649
650 cached_has_bits = _impl_._has_bits_[0];
651 // optional int32 bytes = 1;
652 if (cached_has_bits & 0x00000010u) {
653 target = stream->EnsureSpace(target);
654 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_bytes(), target);
655 }
656
657 // optional string cmdline = 2;
658 if (cached_has_bits & 0x00000001u) {
659 target = stream->WriteStringMaybeAliased(
660 2, this->_internal_cmdline(), target);
661 }
662
663 // optional int64 i_size = 3;
664 if (cached_has_bits & 0x00000004u) {
665 target = stream->EnsureSpace(target);
666 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_i_size(), target);
667 }
668
669 // optional uint64 ino = 4;
670 if (cached_has_bits & 0x00000008u) {
671 target = stream->EnsureSpace(target);
672 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_ino(), target);
673 }
674
675 // optional int64 offset = 5;
676 if (cached_has_bits & 0x00000040u) {
677 target = stream->EnsureSpace(target);
678 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_offset(), target);
679 }
680
681 // optional string pathbuf = 6;
682 if (cached_has_bits & 0x00000002u) {
683 target = stream->WriteStringMaybeAliased(
684 6, this->_internal_pathbuf(), target);
685 }
686
687 // optional int32 pid = 7;
688 if (cached_has_bits & 0x00000020u) {
689 target = stream->EnsureSpace(target);
690 target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_pid(), target);
691 }
692
693 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
694 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
695 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
696 }
697 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
698 return target;
699 }
700
ByteSizeLong() const701 size_t AndroidFsDatareadStartFtraceEvent::ByteSizeLong() const {
702 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
703 size_t total_size = 0;
704
705 ::uint32_t cached_has_bits = 0;
706 // Prevent compiler warnings about cached_has_bits being unused
707 (void) cached_has_bits;
708
709 cached_has_bits = _impl_._has_bits_[0];
710 if (cached_has_bits & 0x0000007fu) {
711 // optional string cmdline = 2;
712 if (cached_has_bits & 0x00000001u) {
713 total_size += 1 +
714 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
715 this->_internal_cmdline());
716 }
717
718 // optional string pathbuf = 6;
719 if (cached_has_bits & 0x00000002u) {
720 total_size += 1 +
721 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
722 this->_internal_pathbuf());
723 }
724
725 // optional int64 i_size = 3;
726 if (cached_has_bits & 0x00000004u) {
727 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_i_size());
728 }
729
730 // optional uint64 ino = 4;
731 if (cached_has_bits & 0x00000008u) {
732 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ino());
733 }
734
735 // optional int32 bytes = 1;
736 if (cached_has_bits & 0x00000010u) {
737 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bytes());
738 }
739
740 // optional int32 pid = 7;
741 if (cached_has_bits & 0x00000020u) {
742 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
743 }
744
745 // optional int64 offset = 5;
746 if (cached_has_bits & 0x00000040u) {
747 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
748 }
749
750 }
751 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
752 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
753 }
754 int cached_size = ::_pbi::ToCachedSize(total_size);
755 SetCachedSize(cached_size);
756 return total_size;
757 }
758
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)759 void AndroidFsDatareadStartFtraceEvent::CheckTypeAndMergeFrom(
760 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
761 MergeFrom(*::_pbi::DownCast<const AndroidFsDatareadStartFtraceEvent*>(
762 &from));
763 }
764
MergeFrom(const AndroidFsDatareadStartFtraceEvent & from)765 void AndroidFsDatareadStartFtraceEvent::MergeFrom(const AndroidFsDatareadStartFtraceEvent& from) {
766 AndroidFsDatareadStartFtraceEvent* const _this = this;
767 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
768 GOOGLE_DCHECK_NE(&from, _this);
769 ::uint32_t cached_has_bits = 0;
770 (void) cached_has_bits;
771
772 cached_has_bits = from._impl_._has_bits_[0];
773 if (cached_has_bits & 0x0000007fu) {
774 if (cached_has_bits & 0x00000001u) {
775 _this->_internal_set_cmdline(from._internal_cmdline());
776 }
777 if (cached_has_bits & 0x00000002u) {
778 _this->_internal_set_pathbuf(from._internal_pathbuf());
779 }
780 if (cached_has_bits & 0x00000004u) {
781 _this->_impl_.i_size_ = from._impl_.i_size_;
782 }
783 if (cached_has_bits & 0x00000008u) {
784 _this->_impl_.ino_ = from._impl_.ino_;
785 }
786 if (cached_has_bits & 0x00000010u) {
787 _this->_impl_.bytes_ = from._impl_.bytes_;
788 }
789 if (cached_has_bits & 0x00000020u) {
790 _this->_impl_.pid_ = from._impl_.pid_;
791 }
792 if (cached_has_bits & 0x00000040u) {
793 _this->_impl_.offset_ = from._impl_.offset_;
794 }
795 _this->_impl_._has_bits_[0] |= cached_has_bits;
796 }
797 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
798 }
799
CopyFrom(const AndroidFsDatareadStartFtraceEvent & from)800 void AndroidFsDatareadStartFtraceEvent::CopyFrom(const AndroidFsDatareadStartFtraceEvent& from) {
801 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidFsDatareadStartFtraceEvent)
802 if (&from == this) return;
803 Clear();
804 MergeFrom(from);
805 }
806
IsInitialized() const807 bool AndroidFsDatareadStartFtraceEvent::IsInitialized() const {
808 return true;
809 }
810
InternalSwap(AndroidFsDatareadStartFtraceEvent * other)811 void AndroidFsDatareadStartFtraceEvent::InternalSwap(AndroidFsDatareadStartFtraceEvent* other) {
812 using std::swap;
813 auto* lhs_arena = GetArenaForAllocation();
814 auto* rhs_arena = other->GetArenaForAllocation();
815 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
816 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
817 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
818 &_impl_.cmdline_, lhs_arena,
819 &other->_impl_.cmdline_, rhs_arena
820 );
821 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
822 &_impl_.pathbuf_, lhs_arena,
823 &other->_impl_.pathbuf_, rhs_arena
824 );
825 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
826 PROTOBUF_FIELD_OFFSET(AndroidFsDatareadStartFtraceEvent, _impl_.offset_)
827 + sizeof(AndroidFsDatareadStartFtraceEvent::_impl_.offset_) // NOLINT
828 - PROTOBUF_FIELD_OFFSET(AndroidFsDatareadStartFtraceEvent, _impl_.i_size_)>(
829 reinterpret_cast<char*>(&_impl_.i_size_),
830 reinterpret_cast<char*>(&other->_impl_.i_size_));
831 }
832
GetTypeName() const833 std::string AndroidFsDatareadStartFtraceEvent::GetTypeName() const {
834 return "perfetto.protos.AndroidFsDatareadStartFtraceEvent";
835 }
836
837
838 // ===================================================================
839
840 class AndroidFsDatawriteEndFtraceEvent::_Internal {
841 public:
842 using HasBits = decltype(std::declval<AndroidFsDatawriteEndFtraceEvent>()._impl_._has_bits_);
set_has_bytes(HasBits * has_bits)843 static void set_has_bytes(HasBits* has_bits) {
844 (*has_bits)[0] |= 4u;
845 }
set_has_ino(HasBits * has_bits)846 static void set_has_ino(HasBits* has_bits) {
847 (*has_bits)[0] |= 1u;
848 }
set_has_offset(HasBits * has_bits)849 static void set_has_offset(HasBits* has_bits) {
850 (*has_bits)[0] |= 2u;
851 }
852 };
853
AndroidFsDatawriteEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)854 AndroidFsDatawriteEndFtraceEvent::AndroidFsDatawriteEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
855 bool is_message_owned)
856 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
857 SharedCtor(arena, is_message_owned);
858 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
859 }
AndroidFsDatawriteEndFtraceEvent(const AndroidFsDatawriteEndFtraceEvent & from)860 AndroidFsDatawriteEndFtraceEvent::AndroidFsDatawriteEndFtraceEvent(const AndroidFsDatawriteEndFtraceEvent& from)
861 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
862 AndroidFsDatawriteEndFtraceEvent* const _this = this; (void)_this;
863 new (&_impl_) Impl_{
864 decltype(_impl_._has_bits_){from._impl_._has_bits_}
865 , /*decltype(_impl_._cached_size_)*/{}
866 , decltype(_impl_.ino_){}
867 , decltype(_impl_.offset_){}
868 , decltype(_impl_.bytes_){}};
869
870 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
871 ::memcpy(&_impl_.ino_, &from._impl_.ino_,
872 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bytes_) -
873 reinterpret_cast<char*>(&_impl_.ino_)) + sizeof(_impl_.bytes_));
874 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
875 }
876
SharedCtor(::_pb::Arena * arena,bool is_message_owned)877 inline void AndroidFsDatawriteEndFtraceEvent::SharedCtor(
878 ::_pb::Arena* arena, bool is_message_owned) {
879 (void)arena;
880 (void)is_message_owned;
881 new (&_impl_) Impl_{
882 decltype(_impl_._has_bits_){}
883 , /*decltype(_impl_._cached_size_)*/{}
884 , decltype(_impl_.ino_){::uint64_t{0u}}
885 , decltype(_impl_.offset_){::int64_t{0}}
886 , decltype(_impl_.bytes_){0}
887 };
888 }
889
~AndroidFsDatawriteEndFtraceEvent()890 AndroidFsDatawriteEndFtraceEvent::~AndroidFsDatawriteEndFtraceEvent() {
891 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
892 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
893 (void)arena;
894 return;
895 }
896 SharedDtor();
897 }
898
SharedDtor()899 inline void AndroidFsDatawriteEndFtraceEvent::SharedDtor() {
900 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
901 }
902
SetCachedSize(int size) const903 void AndroidFsDatawriteEndFtraceEvent::SetCachedSize(int size) const {
904 _impl_._cached_size_.Set(size);
905 }
906
Clear()907 void AndroidFsDatawriteEndFtraceEvent::Clear() {
908 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
909 ::uint32_t cached_has_bits = 0;
910 // Prevent compiler warnings about cached_has_bits being unused
911 (void) cached_has_bits;
912
913 cached_has_bits = _impl_._has_bits_[0];
914 if (cached_has_bits & 0x00000007u) {
915 ::memset(&_impl_.ino_, 0, static_cast<size_t>(
916 reinterpret_cast<char*>(&_impl_.bytes_) -
917 reinterpret_cast<char*>(&_impl_.ino_)) + sizeof(_impl_.bytes_));
918 }
919 _impl_._has_bits_.Clear();
920 _internal_metadata_.Clear<std::string>();
921 }
922
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)923 const char* AndroidFsDatawriteEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
924 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
925 _Internal::HasBits has_bits{};
926 while (!ctx->Done(&ptr)) {
927 ::uint32_t tag;
928 ptr = ::_pbi::ReadTag(ptr, &tag);
929 switch (tag >> 3) {
930 // optional int32 bytes = 1;
931 case 1:
932 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
933 _Internal::set_has_bytes(&has_bits);
934 _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
935 CHK_(ptr);
936 } else {
937 goto handle_unusual;
938 }
939 continue;
940 // optional uint64 ino = 2;
941 case 2:
942 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
943 _Internal::set_has_ino(&has_bits);
944 _impl_.ino_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
945 CHK_(ptr);
946 } else {
947 goto handle_unusual;
948 }
949 continue;
950 // optional int64 offset = 3;
951 case 3:
952 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
953 _Internal::set_has_offset(&has_bits);
954 _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
955 CHK_(ptr);
956 } else {
957 goto handle_unusual;
958 }
959 continue;
960 default:
961 goto handle_unusual;
962 } // switch
963 handle_unusual:
964 if ((tag == 0) || ((tag & 7) == 4)) {
965 CHK_(ptr);
966 ctx->SetLastTag(tag);
967 goto message_done;
968 }
969 ptr = UnknownFieldParse(
970 tag,
971 _internal_metadata_.mutable_unknown_fields<std::string>(),
972 ptr, ctx);
973 CHK_(ptr != nullptr);
974 } // while
975 message_done:
976 _impl_._has_bits_.Or(has_bits);
977 return ptr;
978 failure:
979 ptr = nullptr;
980 goto message_done;
981 #undef CHK_
982 }
983
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const984 ::uint8_t* AndroidFsDatawriteEndFtraceEvent::_InternalSerialize(
985 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
986 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
987 ::uint32_t cached_has_bits = 0;
988 (void) cached_has_bits;
989
990 cached_has_bits = _impl_._has_bits_[0];
991 // optional int32 bytes = 1;
992 if (cached_has_bits & 0x00000004u) {
993 target = stream->EnsureSpace(target);
994 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_bytes(), target);
995 }
996
997 // optional uint64 ino = 2;
998 if (cached_has_bits & 0x00000001u) {
999 target = stream->EnsureSpace(target);
1000 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ino(), target);
1001 }
1002
1003 // optional int64 offset = 3;
1004 if (cached_has_bits & 0x00000002u) {
1005 target = stream->EnsureSpace(target);
1006 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target);
1007 }
1008
1009 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1010 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1011 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1012 }
1013 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
1014 return target;
1015 }
1016
ByteSizeLong() const1017 size_t AndroidFsDatawriteEndFtraceEvent::ByteSizeLong() const {
1018 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
1019 size_t total_size = 0;
1020
1021 ::uint32_t cached_has_bits = 0;
1022 // Prevent compiler warnings about cached_has_bits being unused
1023 (void) cached_has_bits;
1024
1025 cached_has_bits = _impl_._has_bits_[0];
1026 if (cached_has_bits & 0x00000007u) {
1027 // optional uint64 ino = 2;
1028 if (cached_has_bits & 0x00000001u) {
1029 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ino());
1030 }
1031
1032 // optional int64 offset = 3;
1033 if (cached_has_bits & 0x00000002u) {
1034 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
1035 }
1036
1037 // optional int32 bytes = 1;
1038 if (cached_has_bits & 0x00000004u) {
1039 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bytes());
1040 }
1041
1042 }
1043 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1044 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1045 }
1046 int cached_size = ::_pbi::ToCachedSize(total_size);
1047 SetCachedSize(cached_size);
1048 return total_size;
1049 }
1050
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1051 void AndroidFsDatawriteEndFtraceEvent::CheckTypeAndMergeFrom(
1052 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1053 MergeFrom(*::_pbi::DownCast<const AndroidFsDatawriteEndFtraceEvent*>(
1054 &from));
1055 }
1056
MergeFrom(const AndroidFsDatawriteEndFtraceEvent & from)1057 void AndroidFsDatawriteEndFtraceEvent::MergeFrom(const AndroidFsDatawriteEndFtraceEvent& from) {
1058 AndroidFsDatawriteEndFtraceEvent* const _this = this;
1059 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
1060 GOOGLE_DCHECK_NE(&from, _this);
1061 ::uint32_t cached_has_bits = 0;
1062 (void) cached_has_bits;
1063
1064 cached_has_bits = from._impl_._has_bits_[0];
1065 if (cached_has_bits & 0x00000007u) {
1066 if (cached_has_bits & 0x00000001u) {
1067 _this->_impl_.ino_ = from._impl_.ino_;
1068 }
1069 if (cached_has_bits & 0x00000002u) {
1070 _this->_impl_.offset_ = from._impl_.offset_;
1071 }
1072 if (cached_has_bits & 0x00000004u) {
1073 _this->_impl_.bytes_ = from._impl_.bytes_;
1074 }
1075 _this->_impl_._has_bits_[0] |= cached_has_bits;
1076 }
1077 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1078 }
1079
CopyFrom(const AndroidFsDatawriteEndFtraceEvent & from)1080 void AndroidFsDatawriteEndFtraceEvent::CopyFrom(const AndroidFsDatawriteEndFtraceEvent& from) {
1081 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidFsDatawriteEndFtraceEvent)
1082 if (&from == this) return;
1083 Clear();
1084 MergeFrom(from);
1085 }
1086
IsInitialized() const1087 bool AndroidFsDatawriteEndFtraceEvent::IsInitialized() const {
1088 return true;
1089 }
1090
InternalSwap(AndroidFsDatawriteEndFtraceEvent * other)1091 void AndroidFsDatawriteEndFtraceEvent::InternalSwap(AndroidFsDatawriteEndFtraceEvent* other) {
1092 using std::swap;
1093 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1094 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1095 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1096 PROTOBUF_FIELD_OFFSET(AndroidFsDatawriteEndFtraceEvent, _impl_.bytes_)
1097 + sizeof(AndroidFsDatawriteEndFtraceEvent::_impl_.bytes_) // NOLINT
1098 - PROTOBUF_FIELD_OFFSET(AndroidFsDatawriteEndFtraceEvent, _impl_.ino_)>(
1099 reinterpret_cast<char*>(&_impl_.ino_),
1100 reinterpret_cast<char*>(&other->_impl_.ino_));
1101 }
1102
GetTypeName() const1103 std::string AndroidFsDatawriteEndFtraceEvent::GetTypeName() const {
1104 return "perfetto.protos.AndroidFsDatawriteEndFtraceEvent";
1105 }
1106
1107
1108 // ===================================================================
1109
1110 class AndroidFsDatawriteStartFtraceEvent::_Internal {
1111 public:
1112 using HasBits = decltype(std::declval<AndroidFsDatawriteStartFtraceEvent>()._impl_._has_bits_);
set_has_bytes(HasBits * has_bits)1113 static void set_has_bytes(HasBits* has_bits) {
1114 (*has_bits)[0] |= 16u;
1115 }
set_has_cmdline(HasBits * has_bits)1116 static void set_has_cmdline(HasBits* has_bits) {
1117 (*has_bits)[0] |= 1u;
1118 }
set_has_i_size(HasBits * has_bits)1119 static void set_has_i_size(HasBits* has_bits) {
1120 (*has_bits)[0] |= 4u;
1121 }
set_has_ino(HasBits * has_bits)1122 static void set_has_ino(HasBits* has_bits) {
1123 (*has_bits)[0] |= 8u;
1124 }
set_has_offset(HasBits * has_bits)1125 static void set_has_offset(HasBits* has_bits) {
1126 (*has_bits)[0] |= 64u;
1127 }
set_has_pathbuf(HasBits * has_bits)1128 static void set_has_pathbuf(HasBits* has_bits) {
1129 (*has_bits)[0] |= 2u;
1130 }
set_has_pid(HasBits * has_bits)1131 static void set_has_pid(HasBits* has_bits) {
1132 (*has_bits)[0] |= 32u;
1133 }
1134 };
1135
AndroidFsDatawriteStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1136 AndroidFsDatawriteStartFtraceEvent::AndroidFsDatawriteStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1137 bool is_message_owned)
1138 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1139 SharedCtor(arena, is_message_owned);
1140 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1141 }
AndroidFsDatawriteStartFtraceEvent(const AndroidFsDatawriteStartFtraceEvent & from)1142 AndroidFsDatawriteStartFtraceEvent::AndroidFsDatawriteStartFtraceEvent(const AndroidFsDatawriteStartFtraceEvent& from)
1143 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1144 AndroidFsDatawriteStartFtraceEvent* const _this = this; (void)_this;
1145 new (&_impl_) Impl_{
1146 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1147 , /*decltype(_impl_._cached_size_)*/{}
1148 , decltype(_impl_.cmdline_){}
1149 , decltype(_impl_.pathbuf_){}
1150 , decltype(_impl_.i_size_){}
1151 , decltype(_impl_.ino_){}
1152 , decltype(_impl_.bytes_){}
1153 , decltype(_impl_.pid_){}
1154 , decltype(_impl_.offset_){}};
1155
1156 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1157 _impl_.cmdline_.InitDefault();
1158 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1159 _impl_.cmdline_.Set("", GetArenaForAllocation());
1160 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1161 if (from._internal_has_cmdline()) {
1162 _this->_impl_.cmdline_.Set(from._internal_cmdline(),
1163 _this->GetArenaForAllocation());
1164 }
1165 _impl_.pathbuf_.InitDefault();
1166 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1167 _impl_.pathbuf_.Set("", GetArenaForAllocation());
1168 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1169 if (from._internal_has_pathbuf()) {
1170 _this->_impl_.pathbuf_.Set(from._internal_pathbuf(),
1171 _this->GetArenaForAllocation());
1172 }
1173 ::memcpy(&_impl_.i_size_, &from._impl_.i_size_,
1174 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.offset_) -
1175 reinterpret_cast<char*>(&_impl_.i_size_)) + sizeof(_impl_.offset_));
1176 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1177 }
1178
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1179 inline void AndroidFsDatawriteStartFtraceEvent::SharedCtor(
1180 ::_pb::Arena* arena, bool is_message_owned) {
1181 (void)arena;
1182 (void)is_message_owned;
1183 new (&_impl_) Impl_{
1184 decltype(_impl_._has_bits_){}
1185 , /*decltype(_impl_._cached_size_)*/{}
1186 , decltype(_impl_.cmdline_){}
1187 , decltype(_impl_.pathbuf_){}
1188 , decltype(_impl_.i_size_){::int64_t{0}}
1189 , decltype(_impl_.ino_){::uint64_t{0u}}
1190 , decltype(_impl_.bytes_){0}
1191 , decltype(_impl_.pid_){0}
1192 , decltype(_impl_.offset_){::int64_t{0}}
1193 };
1194 _impl_.cmdline_.InitDefault();
1195 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1196 _impl_.cmdline_.Set("", GetArenaForAllocation());
1197 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1198 _impl_.pathbuf_.InitDefault();
1199 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1200 _impl_.pathbuf_.Set("", GetArenaForAllocation());
1201 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1202 }
1203
~AndroidFsDatawriteStartFtraceEvent()1204 AndroidFsDatawriteStartFtraceEvent::~AndroidFsDatawriteStartFtraceEvent() {
1205 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1206 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1207 (void)arena;
1208 return;
1209 }
1210 SharedDtor();
1211 }
1212
SharedDtor()1213 inline void AndroidFsDatawriteStartFtraceEvent::SharedDtor() {
1214 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1215 _impl_.cmdline_.Destroy();
1216 _impl_.pathbuf_.Destroy();
1217 }
1218
SetCachedSize(int size) const1219 void AndroidFsDatawriteStartFtraceEvent::SetCachedSize(int size) const {
1220 _impl_._cached_size_.Set(size);
1221 }
1222
Clear()1223 void AndroidFsDatawriteStartFtraceEvent::Clear() {
1224 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1225 ::uint32_t cached_has_bits = 0;
1226 // Prevent compiler warnings about cached_has_bits being unused
1227 (void) cached_has_bits;
1228
1229 cached_has_bits = _impl_._has_bits_[0];
1230 if (cached_has_bits & 0x00000003u) {
1231 if (cached_has_bits & 0x00000001u) {
1232 _impl_.cmdline_.ClearNonDefaultToEmpty();
1233 }
1234 if (cached_has_bits & 0x00000002u) {
1235 _impl_.pathbuf_.ClearNonDefaultToEmpty();
1236 }
1237 }
1238 if (cached_has_bits & 0x0000007cu) {
1239 ::memset(&_impl_.i_size_, 0, static_cast<size_t>(
1240 reinterpret_cast<char*>(&_impl_.offset_) -
1241 reinterpret_cast<char*>(&_impl_.i_size_)) + sizeof(_impl_.offset_));
1242 }
1243 _impl_._has_bits_.Clear();
1244 _internal_metadata_.Clear<std::string>();
1245 }
1246
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1247 const char* AndroidFsDatawriteStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1248 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1249 _Internal::HasBits has_bits{};
1250 while (!ctx->Done(&ptr)) {
1251 ::uint32_t tag;
1252 ptr = ::_pbi::ReadTag(ptr, &tag);
1253 switch (tag >> 3) {
1254 // optional int32 bytes = 1;
1255 case 1:
1256 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1257 _Internal::set_has_bytes(&has_bits);
1258 _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1259 CHK_(ptr);
1260 } else {
1261 goto handle_unusual;
1262 }
1263 continue;
1264 // optional string cmdline = 2;
1265 case 2:
1266 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1267 auto str = _internal_mutable_cmdline();
1268 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1269 CHK_(ptr);
1270 } else {
1271 goto handle_unusual;
1272 }
1273 continue;
1274 // optional int64 i_size = 3;
1275 case 3:
1276 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1277 _Internal::set_has_i_size(&has_bits);
1278 _impl_.i_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1279 CHK_(ptr);
1280 } else {
1281 goto handle_unusual;
1282 }
1283 continue;
1284 // optional uint64 ino = 4;
1285 case 4:
1286 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1287 _Internal::set_has_ino(&has_bits);
1288 _impl_.ino_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1289 CHK_(ptr);
1290 } else {
1291 goto handle_unusual;
1292 }
1293 continue;
1294 // optional int64 offset = 5;
1295 case 5:
1296 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1297 _Internal::set_has_offset(&has_bits);
1298 _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1299 CHK_(ptr);
1300 } else {
1301 goto handle_unusual;
1302 }
1303 continue;
1304 // optional string pathbuf = 6;
1305 case 6:
1306 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1307 auto str = _internal_mutable_pathbuf();
1308 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1309 CHK_(ptr);
1310 } else {
1311 goto handle_unusual;
1312 }
1313 continue;
1314 // optional int32 pid = 7;
1315 case 7:
1316 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1317 _Internal::set_has_pid(&has_bits);
1318 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1319 CHK_(ptr);
1320 } else {
1321 goto handle_unusual;
1322 }
1323 continue;
1324 default:
1325 goto handle_unusual;
1326 } // switch
1327 handle_unusual:
1328 if ((tag == 0) || ((tag & 7) == 4)) {
1329 CHK_(ptr);
1330 ctx->SetLastTag(tag);
1331 goto message_done;
1332 }
1333 ptr = UnknownFieldParse(
1334 tag,
1335 _internal_metadata_.mutable_unknown_fields<std::string>(),
1336 ptr, ctx);
1337 CHK_(ptr != nullptr);
1338 } // while
1339 message_done:
1340 _impl_._has_bits_.Or(has_bits);
1341 return ptr;
1342 failure:
1343 ptr = nullptr;
1344 goto message_done;
1345 #undef CHK_
1346 }
1347
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1348 ::uint8_t* AndroidFsDatawriteStartFtraceEvent::_InternalSerialize(
1349 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1350 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1351 ::uint32_t cached_has_bits = 0;
1352 (void) cached_has_bits;
1353
1354 cached_has_bits = _impl_._has_bits_[0];
1355 // optional int32 bytes = 1;
1356 if (cached_has_bits & 0x00000010u) {
1357 target = stream->EnsureSpace(target);
1358 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_bytes(), target);
1359 }
1360
1361 // optional string cmdline = 2;
1362 if (cached_has_bits & 0x00000001u) {
1363 target = stream->WriteStringMaybeAliased(
1364 2, this->_internal_cmdline(), target);
1365 }
1366
1367 // optional int64 i_size = 3;
1368 if (cached_has_bits & 0x00000004u) {
1369 target = stream->EnsureSpace(target);
1370 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_i_size(), target);
1371 }
1372
1373 // optional uint64 ino = 4;
1374 if (cached_has_bits & 0x00000008u) {
1375 target = stream->EnsureSpace(target);
1376 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_ino(), target);
1377 }
1378
1379 // optional int64 offset = 5;
1380 if (cached_has_bits & 0x00000040u) {
1381 target = stream->EnsureSpace(target);
1382 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_offset(), target);
1383 }
1384
1385 // optional string pathbuf = 6;
1386 if (cached_has_bits & 0x00000002u) {
1387 target = stream->WriteStringMaybeAliased(
1388 6, this->_internal_pathbuf(), target);
1389 }
1390
1391 // optional int32 pid = 7;
1392 if (cached_has_bits & 0x00000020u) {
1393 target = stream->EnsureSpace(target);
1394 target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_pid(), target);
1395 }
1396
1397 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1398 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1399 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1400 }
1401 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1402 return target;
1403 }
1404
ByteSizeLong() const1405 size_t AndroidFsDatawriteStartFtraceEvent::ByteSizeLong() const {
1406 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1407 size_t total_size = 0;
1408
1409 ::uint32_t cached_has_bits = 0;
1410 // Prevent compiler warnings about cached_has_bits being unused
1411 (void) cached_has_bits;
1412
1413 cached_has_bits = _impl_._has_bits_[0];
1414 if (cached_has_bits & 0x0000007fu) {
1415 // optional string cmdline = 2;
1416 if (cached_has_bits & 0x00000001u) {
1417 total_size += 1 +
1418 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1419 this->_internal_cmdline());
1420 }
1421
1422 // optional string pathbuf = 6;
1423 if (cached_has_bits & 0x00000002u) {
1424 total_size += 1 +
1425 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1426 this->_internal_pathbuf());
1427 }
1428
1429 // optional int64 i_size = 3;
1430 if (cached_has_bits & 0x00000004u) {
1431 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_i_size());
1432 }
1433
1434 // optional uint64 ino = 4;
1435 if (cached_has_bits & 0x00000008u) {
1436 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ino());
1437 }
1438
1439 // optional int32 bytes = 1;
1440 if (cached_has_bits & 0x00000010u) {
1441 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bytes());
1442 }
1443
1444 // optional int32 pid = 7;
1445 if (cached_has_bits & 0x00000020u) {
1446 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
1447 }
1448
1449 // optional int64 offset = 5;
1450 if (cached_has_bits & 0x00000040u) {
1451 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
1452 }
1453
1454 }
1455 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1456 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1457 }
1458 int cached_size = ::_pbi::ToCachedSize(total_size);
1459 SetCachedSize(cached_size);
1460 return total_size;
1461 }
1462
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1463 void AndroidFsDatawriteStartFtraceEvent::CheckTypeAndMergeFrom(
1464 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1465 MergeFrom(*::_pbi::DownCast<const AndroidFsDatawriteStartFtraceEvent*>(
1466 &from));
1467 }
1468
MergeFrom(const AndroidFsDatawriteStartFtraceEvent & from)1469 void AndroidFsDatawriteStartFtraceEvent::MergeFrom(const AndroidFsDatawriteStartFtraceEvent& from) {
1470 AndroidFsDatawriteStartFtraceEvent* const _this = this;
1471 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1472 GOOGLE_DCHECK_NE(&from, _this);
1473 ::uint32_t cached_has_bits = 0;
1474 (void) cached_has_bits;
1475
1476 cached_has_bits = from._impl_._has_bits_[0];
1477 if (cached_has_bits & 0x0000007fu) {
1478 if (cached_has_bits & 0x00000001u) {
1479 _this->_internal_set_cmdline(from._internal_cmdline());
1480 }
1481 if (cached_has_bits & 0x00000002u) {
1482 _this->_internal_set_pathbuf(from._internal_pathbuf());
1483 }
1484 if (cached_has_bits & 0x00000004u) {
1485 _this->_impl_.i_size_ = from._impl_.i_size_;
1486 }
1487 if (cached_has_bits & 0x00000008u) {
1488 _this->_impl_.ino_ = from._impl_.ino_;
1489 }
1490 if (cached_has_bits & 0x00000010u) {
1491 _this->_impl_.bytes_ = from._impl_.bytes_;
1492 }
1493 if (cached_has_bits & 0x00000020u) {
1494 _this->_impl_.pid_ = from._impl_.pid_;
1495 }
1496 if (cached_has_bits & 0x00000040u) {
1497 _this->_impl_.offset_ = from._impl_.offset_;
1498 }
1499 _this->_impl_._has_bits_[0] |= cached_has_bits;
1500 }
1501 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1502 }
1503
CopyFrom(const AndroidFsDatawriteStartFtraceEvent & from)1504 void AndroidFsDatawriteStartFtraceEvent::CopyFrom(const AndroidFsDatawriteStartFtraceEvent& from) {
1505 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidFsDatawriteStartFtraceEvent)
1506 if (&from == this) return;
1507 Clear();
1508 MergeFrom(from);
1509 }
1510
IsInitialized() const1511 bool AndroidFsDatawriteStartFtraceEvent::IsInitialized() const {
1512 return true;
1513 }
1514
InternalSwap(AndroidFsDatawriteStartFtraceEvent * other)1515 void AndroidFsDatawriteStartFtraceEvent::InternalSwap(AndroidFsDatawriteStartFtraceEvent* other) {
1516 using std::swap;
1517 auto* lhs_arena = GetArenaForAllocation();
1518 auto* rhs_arena = other->GetArenaForAllocation();
1519 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1520 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1521 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1522 &_impl_.cmdline_, lhs_arena,
1523 &other->_impl_.cmdline_, rhs_arena
1524 );
1525 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1526 &_impl_.pathbuf_, lhs_arena,
1527 &other->_impl_.pathbuf_, rhs_arena
1528 );
1529 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1530 PROTOBUF_FIELD_OFFSET(AndroidFsDatawriteStartFtraceEvent, _impl_.offset_)
1531 + sizeof(AndroidFsDatawriteStartFtraceEvent::_impl_.offset_) // NOLINT
1532 - PROTOBUF_FIELD_OFFSET(AndroidFsDatawriteStartFtraceEvent, _impl_.i_size_)>(
1533 reinterpret_cast<char*>(&_impl_.i_size_),
1534 reinterpret_cast<char*>(&other->_impl_.i_size_));
1535 }
1536
GetTypeName() const1537 std::string AndroidFsDatawriteStartFtraceEvent::GetTypeName() const {
1538 return "perfetto.protos.AndroidFsDatawriteStartFtraceEvent";
1539 }
1540
1541
1542 // ===================================================================
1543
1544 class AndroidFsFsyncEndFtraceEvent::_Internal {
1545 public:
1546 using HasBits = decltype(std::declval<AndroidFsFsyncEndFtraceEvent>()._impl_._has_bits_);
set_has_bytes(HasBits * has_bits)1547 static void set_has_bytes(HasBits* has_bits) {
1548 (*has_bits)[0] |= 4u;
1549 }
set_has_ino(HasBits * has_bits)1550 static void set_has_ino(HasBits* has_bits) {
1551 (*has_bits)[0] |= 1u;
1552 }
set_has_offset(HasBits * has_bits)1553 static void set_has_offset(HasBits* has_bits) {
1554 (*has_bits)[0] |= 2u;
1555 }
1556 };
1557
AndroidFsFsyncEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1558 AndroidFsFsyncEndFtraceEvent::AndroidFsFsyncEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1559 bool is_message_owned)
1560 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1561 SharedCtor(arena, is_message_owned);
1562 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1563 }
AndroidFsFsyncEndFtraceEvent(const AndroidFsFsyncEndFtraceEvent & from)1564 AndroidFsFsyncEndFtraceEvent::AndroidFsFsyncEndFtraceEvent(const AndroidFsFsyncEndFtraceEvent& from)
1565 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1566 AndroidFsFsyncEndFtraceEvent* const _this = this; (void)_this;
1567 new (&_impl_) Impl_{
1568 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1569 , /*decltype(_impl_._cached_size_)*/{}
1570 , decltype(_impl_.ino_){}
1571 , decltype(_impl_.offset_){}
1572 , decltype(_impl_.bytes_){}};
1573
1574 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1575 ::memcpy(&_impl_.ino_, &from._impl_.ino_,
1576 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.bytes_) -
1577 reinterpret_cast<char*>(&_impl_.ino_)) + sizeof(_impl_.bytes_));
1578 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1579 }
1580
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1581 inline void AndroidFsFsyncEndFtraceEvent::SharedCtor(
1582 ::_pb::Arena* arena, bool is_message_owned) {
1583 (void)arena;
1584 (void)is_message_owned;
1585 new (&_impl_) Impl_{
1586 decltype(_impl_._has_bits_){}
1587 , /*decltype(_impl_._cached_size_)*/{}
1588 , decltype(_impl_.ino_){::uint64_t{0u}}
1589 , decltype(_impl_.offset_){::int64_t{0}}
1590 , decltype(_impl_.bytes_){0}
1591 };
1592 }
1593
~AndroidFsFsyncEndFtraceEvent()1594 AndroidFsFsyncEndFtraceEvent::~AndroidFsFsyncEndFtraceEvent() {
1595 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1596 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1597 (void)arena;
1598 return;
1599 }
1600 SharedDtor();
1601 }
1602
SharedDtor()1603 inline void AndroidFsFsyncEndFtraceEvent::SharedDtor() {
1604 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1605 }
1606
SetCachedSize(int size) const1607 void AndroidFsFsyncEndFtraceEvent::SetCachedSize(int size) const {
1608 _impl_._cached_size_.Set(size);
1609 }
1610
Clear()1611 void AndroidFsFsyncEndFtraceEvent::Clear() {
1612 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1613 ::uint32_t cached_has_bits = 0;
1614 // Prevent compiler warnings about cached_has_bits being unused
1615 (void) cached_has_bits;
1616
1617 cached_has_bits = _impl_._has_bits_[0];
1618 if (cached_has_bits & 0x00000007u) {
1619 ::memset(&_impl_.ino_, 0, static_cast<size_t>(
1620 reinterpret_cast<char*>(&_impl_.bytes_) -
1621 reinterpret_cast<char*>(&_impl_.ino_)) + sizeof(_impl_.bytes_));
1622 }
1623 _impl_._has_bits_.Clear();
1624 _internal_metadata_.Clear<std::string>();
1625 }
1626
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1627 const char* AndroidFsFsyncEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1628 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1629 _Internal::HasBits has_bits{};
1630 while (!ctx->Done(&ptr)) {
1631 ::uint32_t tag;
1632 ptr = ::_pbi::ReadTag(ptr, &tag);
1633 switch (tag >> 3) {
1634 // optional int32 bytes = 1;
1635 case 1:
1636 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1637 _Internal::set_has_bytes(&has_bits);
1638 _impl_.bytes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1639 CHK_(ptr);
1640 } else {
1641 goto handle_unusual;
1642 }
1643 continue;
1644 // optional uint64 ino = 2;
1645 case 2:
1646 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1647 _Internal::set_has_ino(&has_bits);
1648 _impl_.ino_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1649 CHK_(ptr);
1650 } else {
1651 goto handle_unusual;
1652 }
1653 continue;
1654 // optional int64 offset = 3;
1655 case 3:
1656 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1657 _Internal::set_has_offset(&has_bits);
1658 _impl_.offset_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1659 CHK_(ptr);
1660 } else {
1661 goto handle_unusual;
1662 }
1663 continue;
1664 default:
1665 goto handle_unusual;
1666 } // switch
1667 handle_unusual:
1668 if ((tag == 0) || ((tag & 7) == 4)) {
1669 CHK_(ptr);
1670 ctx->SetLastTag(tag);
1671 goto message_done;
1672 }
1673 ptr = UnknownFieldParse(
1674 tag,
1675 _internal_metadata_.mutable_unknown_fields<std::string>(),
1676 ptr, ctx);
1677 CHK_(ptr != nullptr);
1678 } // while
1679 message_done:
1680 _impl_._has_bits_.Or(has_bits);
1681 return ptr;
1682 failure:
1683 ptr = nullptr;
1684 goto message_done;
1685 #undef CHK_
1686 }
1687
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1688 ::uint8_t* AndroidFsFsyncEndFtraceEvent::_InternalSerialize(
1689 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1690 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1691 ::uint32_t cached_has_bits = 0;
1692 (void) cached_has_bits;
1693
1694 cached_has_bits = _impl_._has_bits_[0];
1695 // optional int32 bytes = 1;
1696 if (cached_has_bits & 0x00000004u) {
1697 target = stream->EnsureSpace(target);
1698 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_bytes(), target);
1699 }
1700
1701 // optional uint64 ino = 2;
1702 if (cached_has_bits & 0x00000001u) {
1703 target = stream->EnsureSpace(target);
1704 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_ino(), target);
1705 }
1706
1707 // optional int64 offset = 3;
1708 if (cached_has_bits & 0x00000002u) {
1709 target = stream->EnsureSpace(target);
1710 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_offset(), target);
1711 }
1712
1713 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1714 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1715 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1716 }
1717 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1718 return target;
1719 }
1720
ByteSizeLong() const1721 size_t AndroidFsFsyncEndFtraceEvent::ByteSizeLong() const {
1722 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1723 size_t total_size = 0;
1724
1725 ::uint32_t cached_has_bits = 0;
1726 // Prevent compiler warnings about cached_has_bits being unused
1727 (void) cached_has_bits;
1728
1729 cached_has_bits = _impl_._has_bits_[0];
1730 if (cached_has_bits & 0x00000007u) {
1731 // optional uint64 ino = 2;
1732 if (cached_has_bits & 0x00000001u) {
1733 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ino());
1734 }
1735
1736 // optional int64 offset = 3;
1737 if (cached_has_bits & 0x00000002u) {
1738 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_offset());
1739 }
1740
1741 // optional int32 bytes = 1;
1742 if (cached_has_bits & 0x00000004u) {
1743 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bytes());
1744 }
1745
1746 }
1747 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1748 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1749 }
1750 int cached_size = ::_pbi::ToCachedSize(total_size);
1751 SetCachedSize(cached_size);
1752 return total_size;
1753 }
1754
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1755 void AndroidFsFsyncEndFtraceEvent::CheckTypeAndMergeFrom(
1756 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1757 MergeFrom(*::_pbi::DownCast<const AndroidFsFsyncEndFtraceEvent*>(
1758 &from));
1759 }
1760
MergeFrom(const AndroidFsFsyncEndFtraceEvent & from)1761 void AndroidFsFsyncEndFtraceEvent::MergeFrom(const AndroidFsFsyncEndFtraceEvent& from) {
1762 AndroidFsFsyncEndFtraceEvent* const _this = this;
1763 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1764 GOOGLE_DCHECK_NE(&from, _this);
1765 ::uint32_t cached_has_bits = 0;
1766 (void) cached_has_bits;
1767
1768 cached_has_bits = from._impl_._has_bits_[0];
1769 if (cached_has_bits & 0x00000007u) {
1770 if (cached_has_bits & 0x00000001u) {
1771 _this->_impl_.ino_ = from._impl_.ino_;
1772 }
1773 if (cached_has_bits & 0x00000002u) {
1774 _this->_impl_.offset_ = from._impl_.offset_;
1775 }
1776 if (cached_has_bits & 0x00000004u) {
1777 _this->_impl_.bytes_ = from._impl_.bytes_;
1778 }
1779 _this->_impl_._has_bits_[0] |= cached_has_bits;
1780 }
1781 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1782 }
1783
CopyFrom(const AndroidFsFsyncEndFtraceEvent & from)1784 void AndroidFsFsyncEndFtraceEvent::CopyFrom(const AndroidFsFsyncEndFtraceEvent& from) {
1785 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidFsFsyncEndFtraceEvent)
1786 if (&from == this) return;
1787 Clear();
1788 MergeFrom(from);
1789 }
1790
IsInitialized() const1791 bool AndroidFsFsyncEndFtraceEvent::IsInitialized() const {
1792 return true;
1793 }
1794
InternalSwap(AndroidFsFsyncEndFtraceEvent * other)1795 void AndroidFsFsyncEndFtraceEvent::InternalSwap(AndroidFsFsyncEndFtraceEvent* other) {
1796 using std::swap;
1797 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1798 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1799 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1800 PROTOBUF_FIELD_OFFSET(AndroidFsFsyncEndFtraceEvent, _impl_.bytes_)
1801 + sizeof(AndroidFsFsyncEndFtraceEvent::_impl_.bytes_) // NOLINT
1802 - PROTOBUF_FIELD_OFFSET(AndroidFsFsyncEndFtraceEvent, _impl_.ino_)>(
1803 reinterpret_cast<char*>(&_impl_.ino_),
1804 reinterpret_cast<char*>(&other->_impl_.ino_));
1805 }
1806
GetTypeName() const1807 std::string AndroidFsFsyncEndFtraceEvent::GetTypeName() const {
1808 return "perfetto.protos.AndroidFsFsyncEndFtraceEvent";
1809 }
1810
1811
1812 // ===================================================================
1813
1814 class AndroidFsFsyncStartFtraceEvent::_Internal {
1815 public:
1816 using HasBits = decltype(std::declval<AndroidFsFsyncStartFtraceEvent>()._impl_._has_bits_);
set_has_cmdline(HasBits * has_bits)1817 static void set_has_cmdline(HasBits* has_bits) {
1818 (*has_bits)[0] |= 1u;
1819 }
set_has_i_size(HasBits * has_bits)1820 static void set_has_i_size(HasBits* has_bits) {
1821 (*has_bits)[0] |= 4u;
1822 }
set_has_ino(HasBits * has_bits)1823 static void set_has_ino(HasBits* has_bits) {
1824 (*has_bits)[0] |= 8u;
1825 }
set_has_pathbuf(HasBits * has_bits)1826 static void set_has_pathbuf(HasBits* has_bits) {
1827 (*has_bits)[0] |= 2u;
1828 }
set_has_pid(HasBits * has_bits)1829 static void set_has_pid(HasBits* has_bits) {
1830 (*has_bits)[0] |= 16u;
1831 }
1832 };
1833
AndroidFsFsyncStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1834 AndroidFsFsyncStartFtraceEvent::AndroidFsFsyncStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1835 bool is_message_owned)
1836 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1837 SharedCtor(arena, is_message_owned);
1838 // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
1839 }
AndroidFsFsyncStartFtraceEvent(const AndroidFsFsyncStartFtraceEvent & from)1840 AndroidFsFsyncStartFtraceEvent::AndroidFsFsyncStartFtraceEvent(const AndroidFsFsyncStartFtraceEvent& from)
1841 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1842 AndroidFsFsyncStartFtraceEvent* const _this = this; (void)_this;
1843 new (&_impl_) Impl_{
1844 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1845 , /*decltype(_impl_._cached_size_)*/{}
1846 , decltype(_impl_.cmdline_){}
1847 , decltype(_impl_.pathbuf_){}
1848 , decltype(_impl_.i_size_){}
1849 , decltype(_impl_.ino_){}
1850 , decltype(_impl_.pid_){}};
1851
1852 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1853 _impl_.cmdline_.InitDefault();
1854 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1855 _impl_.cmdline_.Set("", GetArenaForAllocation());
1856 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1857 if (from._internal_has_cmdline()) {
1858 _this->_impl_.cmdline_.Set(from._internal_cmdline(),
1859 _this->GetArenaForAllocation());
1860 }
1861 _impl_.pathbuf_.InitDefault();
1862 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1863 _impl_.pathbuf_.Set("", GetArenaForAllocation());
1864 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1865 if (from._internal_has_pathbuf()) {
1866 _this->_impl_.pathbuf_.Set(from._internal_pathbuf(),
1867 _this->GetArenaForAllocation());
1868 }
1869 ::memcpy(&_impl_.i_size_, &from._impl_.i_size_,
1870 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.pid_) -
1871 reinterpret_cast<char*>(&_impl_.i_size_)) + sizeof(_impl_.pid_));
1872 // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
1873 }
1874
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1875 inline void AndroidFsFsyncStartFtraceEvent::SharedCtor(
1876 ::_pb::Arena* arena, bool is_message_owned) {
1877 (void)arena;
1878 (void)is_message_owned;
1879 new (&_impl_) Impl_{
1880 decltype(_impl_._has_bits_){}
1881 , /*decltype(_impl_._cached_size_)*/{}
1882 , decltype(_impl_.cmdline_){}
1883 , decltype(_impl_.pathbuf_){}
1884 , decltype(_impl_.i_size_){::int64_t{0}}
1885 , decltype(_impl_.ino_){::uint64_t{0u}}
1886 , decltype(_impl_.pid_){0}
1887 };
1888 _impl_.cmdline_.InitDefault();
1889 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1890 _impl_.cmdline_.Set("", GetArenaForAllocation());
1891 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1892 _impl_.pathbuf_.InitDefault();
1893 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1894 _impl_.pathbuf_.Set("", GetArenaForAllocation());
1895 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1896 }
1897
~AndroidFsFsyncStartFtraceEvent()1898 AndroidFsFsyncStartFtraceEvent::~AndroidFsFsyncStartFtraceEvent() {
1899 // @@protoc_insertion_point(destructor:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
1900 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1901 (void)arena;
1902 return;
1903 }
1904 SharedDtor();
1905 }
1906
SharedDtor()1907 inline void AndroidFsFsyncStartFtraceEvent::SharedDtor() {
1908 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1909 _impl_.cmdline_.Destroy();
1910 _impl_.pathbuf_.Destroy();
1911 }
1912
SetCachedSize(int size) const1913 void AndroidFsFsyncStartFtraceEvent::SetCachedSize(int size) const {
1914 _impl_._cached_size_.Set(size);
1915 }
1916
Clear()1917 void AndroidFsFsyncStartFtraceEvent::Clear() {
1918 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
1919 ::uint32_t cached_has_bits = 0;
1920 // Prevent compiler warnings about cached_has_bits being unused
1921 (void) cached_has_bits;
1922
1923 cached_has_bits = _impl_._has_bits_[0];
1924 if (cached_has_bits & 0x00000003u) {
1925 if (cached_has_bits & 0x00000001u) {
1926 _impl_.cmdline_.ClearNonDefaultToEmpty();
1927 }
1928 if (cached_has_bits & 0x00000002u) {
1929 _impl_.pathbuf_.ClearNonDefaultToEmpty();
1930 }
1931 }
1932 if (cached_has_bits & 0x0000001cu) {
1933 ::memset(&_impl_.i_size_, 0, static_cast<size_t>(
1934 reinterpret_cast<char*>(&_impl_.pid_) -
1935 reinterpret_cast<char*>(&_impl_.i_size_)) + sizeof(_impl_.pid_));
1936 }
1937 _impl_._has_bits_.Clear();
1938 _internal_metadata_.Clear<std::string>();
1939 }
1940
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1941 const char* AndroidFsFsyncStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1942 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1943 _Internal::HasBits has_bits{};
1944 while (!ctx->Done(&ptr)) {
1945 ::uint32_t tag;
1946 ptr = ::_pbi::ReadTag(ptr, &tag);
1947 switch (tag >> 3) {
1948 // optional string cmdline = 1;
1949 case 1:
1950 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1951 auto str = _internal_mutable_cmdline();
1952 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1953 CHK_(ptr);
1954 } else {
1955 goto handle_unusual;
1956 }
1957 continue;
1958 // optional int64 i_size = 2;
1959 case 2:
1960 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1961 _Internal::set_has_i_size(&has_bits);
1962 _impl_.i_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1963 CHK_(ptr);
1964 } else {
1965 goto handle_unusual;
1966 }
1967 continue;
1968 // optional uint64 ino = 3;
1969 case 3:
1970 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1971 _Internal::set_has_ino(&has_bits);
1972 _impl_.ino_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1973 CHK_(ptr);
1974 } else {
1975 goto handle_unusual;
1976 }
1977 continue;
1978 // optional string pathbuf = 4;
1979 case 4:
1980 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1981 auto str = _internal_mutable_pathbuf();
1982 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1983 CHK_(ptr);
1984 } else {
1985 goto handle_unusual;
1986 }
1987 continue;
1988 // optional int32 pid = 5;
1989 case 5:
1990 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1991 _Internal::set_has_pid(&has_bits);
1992 _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1993 CHK_(ptr);
1994 } else {
1995 goto handle_unusual;
1996 }
1997 continue;
1998 default:
1999 goto handle_unusual;
2000 } // switch
2001 handle_unusual:
2002 if ((tag == 0) || ((tag & 7) == 4)) {
2003 CHK_(ptr);
2004 ctx->SetLastTag(tag);
2005 goto message_done;
2006 }
2007 ptr = UnknownFieldParse(
2008 tag,
2009 _internal_metadata_.mutable_unknown_fields<std::string>(),
2010 ptr, ctx);
2011 CHK_(ptr != nullptr);
2012 } // while
2013 message_done:
2014 _impl_._has_bits_.Or(has_bits);
2015 return ptr;
2016 failure:
2017 ptr = nullptr;
2018 goto message_done;
2019 #undef CHK_
2020 }
2021
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const2022 ::uint8_t* AndroidFsFsyncStartFtraceEvent::_InternalSerialize(
2023 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
2024 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
2025 ::uint32_t cached_has_bits = 0;
2026 (void) cached_has_bits;
2027
2028 cached_has_bits = _impl_._has_bits_[0];
2029 // optional string cmdline = 1;
2030 if (cached_has_bits & 0x00000001u) {
2031 target = stream->WriteStringMaybeAliased(
2032 1, this->_internal_cmdline(), target);
2033 }
2034
2035 // optional int64 i_size = 2;
2036 if (cached_has_bits & 0x00000004u) {
2037 target = stream->EnsureSpace(target);
2038 target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_i_size(), target);
2039 }
2040
2041 // optional uint64 ino = 3;
2042 if (cached_has_bits & 0x00000008u) {
2043 target = stream->EnsureSpace(target);
2044 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_ino(), target);
2045 }
2046
2047 // optional string pathbuf = 4;
2048 if (cached_has_bits & 0x00000002u) {
2049 target = stream->WriteStringMaybeAliased(
2050 4, this->_internal_pathbuf(), target);
2051 }
2052
2053 // optional int32 pid = 5;
2054 if (cached_has_bits & 0x00000010u) {
2055 target = stream->EnsureSpace(target);
2056 target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_pid(), target);
2057 }
2058
2059 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2060 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2061 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2062 }
2063 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
2064 return target;
2065 }
2066
ByteSizeLong() const2067 size_t AndroidFsFsyncStartFtraceEvent::ByteSizeLong() const {
2068 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
2069 size_t total_size = 0;
2070
2071 ::uint32_t cached_has_bits = 0;
2072 // Prevent compiler warnings about cached_has_bits being unused
2073 (void) cached_has_bits;
2074
2075 cached_has_bits = _impl_._has_bits_[0];
2076 if (cached_has_bits & 0x0000001fu) {
2077 // optional string cmdline = 1;
2078 if (cached_has_bits & 0x00000001u) {
2079 total_size += 1 +
2080 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2081 this->_internal_cmdline());
2082 }
2083
2084 // optional string pathbuf = 4;
2085 if (cached_has_bits & 0x00000002u) {
2086 total_size += 1 +
2087 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
2088 this->_internal_pathbuf());
2089 }
2090
2091 // optional int64 i_size = 2;
2092 if (cached_has_bits & 0x00000004u) {
2093 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_i_size());
2094 }
2095
2096 // optional uint64 ino = 3;
2097 if (cached_has_bits & 0x00000008u) {
2098 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ino());
2099 }
2100
2101 // optional int32 pid = 5;
2102 if (cached_has_bits & 0x00000010u) {
2103 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
2104 }
2105
2106 }
2107 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2108 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2109 }
2110 int cached_size = ::_pbi::ToCachedSize(total_size);
2111 SetCachedSize(cached_size);
2112 return total_size;
2113 }
2114
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2115 void AndroidFsFsyncStartFtraceEvent::CheckTypeAndMergeFrom(
2116 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2117 MergeFrom(*::_pbi::DownCast<const AndroidFsFsyncStartFtraceEvent*>(
2118 &from));
2119 }
2120
MergeFrom(const AndroidFsFsyncStartFtraceEvent & from)2121 void AndroidFsFsyncStartFtraceEvent::MergeFrom(const AndroidFsFsyncStartFtraceEvent& from) {
2122 AndroidFsFsyncStartFtraceEvent* const _this = this;
2123 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
2124 GOOGLE_DCHECK_NE(&from, _this);
2125 ::uint32_t cached_has_bits = 0;
2126 (void) cached_has_bits;
2127
2128 cached_has_bits = from._impl_._has_bits_[0];
2129 if (cached_has_bits & 0x0000001fu) {
2130 if (cached_has_bits & 0x00000001u) {
2131 _this->_internal_set_cmdline(from._internal_cmdline());
2132 }
2133 if (cached_has_bits & 0x00000002u) {
2134 _this->_internal_set_pathbuf(from._internal_pathbuf());
2135 }
2136 if (cached_has_bits & 0x00000004u) {
2137 _this->_impl_.i_size_ = from._impl_.i_size_;
2138 }
2139 if (cached_has_bits & 0x00000008u) {
2140 _this->_impl_.ino_ = from._impl_.ino_;
2141 }
2142 if (cached_has_bits & 0x00000010u) {
2143 _this->_impl_.pid_ = from._impl_.pid_;
2144 }
2145 _this->_impl_._has_bits_[0] |= cached_has_bits;
2146 }
2147 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2148 }
2149
CopyFrom(const AndroidFsFsyncStartFtraceEvent & from)2150 void AndroidFsFsyncStartFtraceEvent::CopyFrom(const AndroidFsFsyncStartFtraceEvent& from) {
2151 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidFsFsyncStartFtraceEvent)
2152 if (&from == this) return;
2153 Clear();
2154 MergeFrom(from);
2155 }
2156
IsInitialized() const2157 bool AndroidFsFsyncStartFtraceEvent::IsInitialized() const {
2158 return true;
2159 }
2160
InternalSwap(AndroidFsFsyncStartFtraceEvent * other)2161 void AndroidFsFsyncStartFtraceEvent::InternalSwap(AndroidFsFsyncStartFtraceEvent* other) {
2162 using std::swap;
2163 auto* lhs_arena = GetArenaForAllocation();
2164 auto* rhs_arena = other->GetArenaForAllocation();
2165 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2166 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2167 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2168 &_impl_.cmdline_, lhs_arena,
2169 &other->_impl_.cmdline_, rhs_arena
2170 );
2171 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2172 &_impl_.pathbuf_, lhs_arena,
2173 &other->_impl_.pathbuf_, rhs_arena
2174 );
2175 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2176 PROTOBUF_FIELD_OFFSET(AndroidFsFsyncStartFtraceEvent, _impl_.pid_)
2177 + sizeof(AndroidFsFsyncStartFtraceEvent::_impl_.pid_) // NOLINT
2178 - PROTOBUF_FIELD_OFFSET(AndroidFsFsyncStartFtraceEvent, _impl_.i_size_)>(
2179 reinterpret_cast<char*>(&_impl_.i_size_),
2180 reinterpret_cast<char*>(&other->_impl_.i_size_));
2181 }
2182
GetTypeName() const2183 std::string AndroidFsFsyncStartFtraceEvent::GetTypeName() const {
2184 return "perfetto.protos.AndroidFsFsyncStartFtraceEvent";
2185 }
2186
2187
2188 // @@protoc_insertion_point(namespace_scope)
2189 } // namespace protos
2190 } // namespace perfetto
2191 PROTOBUF_NAMESPACE_OPEN
2192 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidFsDatareadEndFtraceEvent*
CreateMaybeMessage(Arena * arena)2193 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidFsDatareadEndFtraceEvent >(Arena* arena) {
2194 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidFsDatareadEndFtraceEvent >(arena);
2195 }
2196 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidFsDatareadStartFtraceEvent*
CreateMaybeMessage(Arena * arena)2197 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidFsDatareadStartFtraceEvent >(Arena* arena) {
2198 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidFsDatareadStartFtraceEvent >(arena);
2199 }
2200 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidFsDatawriteEndFtraceEvent*
CreateMaybeMessage(Arena * arena)2201 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidFsDatawriteEndFtraceEvent >(Arena* arena) {
2202 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidFsDatawriteEndFtraceEvent >(arena);
2203 }
2204 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidFsDatawriteStartFtraceEvent*
CreateMaybeMessage(Arena * arena)2205 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidFsDatawriteStartFtraceEvent >(Arena* arena) {
2206 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidFsDatawriteStartFtraceEvent >(arena);
2207 }
2208 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidFsFsyncEndFtraceEvent*
CreateMaybeMessage(Arena * arena)2209 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidFsFsyncEndFtraceEvent >(Arena* arena) {
2210 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidFsFsyncEndFtraceEvent >(arena);
2211 }
2212 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidFsFsyncStartFtraceEvent*
CreateMaybeMessage(Arena * arena)2213 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidFsFsyncStartFtraceEvent >(Arena* arena) {
2214 return Arena::CreateMessageInternal< ::perfetto::protos::AndroidFsFsyncStartFtraceEvent >(arena);
2215 }
2216 PROTOBUF_NAMESPACE_CLOSE
2217
2218 // @@protoc_insertion_point(global_scope)
2219 #include <google/protobuf/port_undef.inc>
2220