1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: system/extras/simpleperf/cmd_report_sample.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto
6
7 #include <cstdint>
8 #include <limits>
9 #include <string>
10
11 #include <google/protobuf/port_def.inc>
12 #if PROTOBUF_VERSION < 3021000
13 #error This file was generated by a newer version of protoc which is
14 #error incompatible with your Protocol Buffer headers. Please update
15 #error your headers.
16 #endif
17 #if 3021012 < PROTOBUF_MIN_PROTOC_VERSION
18 #error This file was generated by an older version of protoc which is
19 #error incompatible with your Protocol Buffer headers. Please
20 #error regenerate this file with a newer version of protoc.
21 #endif
22
23 #include <google/protobuf/port_undef.inc>
24 #include <google/protobuf/io/coded_stream.h>
25 #include <google/protobuf/arena.h>
26 #include <google/protobuf/arenastring.h>
27 #include <google/protobuf/generated_message_util.h>
28 #include <google/protobuf/metadata_lite.h>
29 #include <google/protobuf/message_lite.h>
30 #include <google/protobuf/repeated_field.h> // IWYU pragma: export
31 #include <google/protobuf/extension_set.h> // IWYU pragma: export
32 #include <google/protobuf/generated_enum_util.h>
33 // @@protoc_insertion_point(includes)
34 #include <google/protobuf/port_def.inc>
35 #define PROTOBUF_INTERNAL_EXPORT_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto
36 PROTOBUF_NAMESPACE_OPEN
37 namespace internal {
38 class AnyMetadata;
39 } // namespace internal
40 PROTOBUF_NAMESPACE_CLOSE
41
42 // Internal implementation detail -- do not use these members.
43 struct TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto {
44 static const ::uint32_t offsets[];
45 };
46 namespace simpleperf_report_proto {
47 class ContextSwitch;
48 struct ContextSwitchDefaultTypeInternal;
49 extern ContextSwitchDefaultTypeInternal _ContextSwitch_default_instance_;
50 class File;
51 struct FileDefaultTypeInternal;
52 extern FileDefaultTypeInternal _File_default_instance_;
53 class LostSituation;
54 struct LostSituationDefaultTypeInternal;
55 extern LostSituationDefaultTypeInternal _LostSituation_default_instance_;
56 class MetaInfo;
57 struct MetaInfoDefaultTypeInternal;
58 extern MetaInfoDefaultTypeInternal _MetaInfo_default_instance_;
59 class Record;
60 struct RecordDefaultTypeInternal;
61 extern RecordDefaultTypeInternal _Record_default_instance_;
62 class Sample;
63 struct SampleDefaultTypeInternal;
64 extern SampleDefaultTypeInternal _Sample_default_instance_;
65 class Sample_CallChainEntry;
66 struct Sample_CallChainEntryDefaultTypeInternal;
67 extern Sample_CallChainEntryDefaultTypeInternal _Sample_CallChainEntry_default_instance_;
68 class Sample_UnwindingResult;
69 struct Sample_UnwindingResultDefaultTypeInternal;
70 extern Sample_UnwindingResultDefaultTypeInternal _Sample_UnwindingResult_default_instance_;
71 class Thread;
72 struct ThreadDefaultTypeInternal;
73 extern ThreadDefaultTypeInternal _Thread_default_instance_;
74 } // namespace simpleperf_report_proto
75 PROTOBUF_NAMESPACE_OPEN
76 template<> ::simpleperf_report_proto::ContextSwitch* Arena::CreateMaybeMessage<::simpleperf_report_proto::ContextSwitch>(Arena*);
77 template<> ::simpleperf_report_proto::File* Arena::CreateMaybeMessage<::simpleperf_report_proto::File>(Arena*);
78 template<> ::simpleperf_report_proto::LostSituation* Arena::CreateMaybeMessage<::simpleperf_report_proto::LostSituation>(Arena*);
79 template<> ::simpleperf_report_proto::MetaInfo* Arena::CreateMaybeMessage<::simpleperf_report_proto::MetaInfo>(Arena*);
80 template<> ::simpleperf_report_proto::Record* Arena::CreateMaybeMessage<::simpleperf_report_proto::Record>(Arena*);
81 template<> ::simpleperf_report_proto::Sample* Arena::CreateMaybeMessage<::simpleperf_report_proto::Sample>(Arena*);
82 template<> ::simpleperf_report_proto::Sample_CallChainEntry* Arena::CreateMaybeMessage<::simpleperf_report_proto::Sample_CallChainEntry>(Arena*);
83 template<> ::simpleperf_report_proto::Sample_UnwindingResult* Arena::CreateMaybeMessage<::simpleperf_report_proto::Sample_UnwindingResult>(Arena*);
84 template<> ::simpleperf_report_proto::Thread* Arena::CreateMaybeMessage<::simpleperf_report_proto::Thread>(Arena*);
85 PROTOBUF_NAMESPACE_CLOSE
86 namespace simpleperf_report_proto {
87
88 enum Sample_CallChainEntry_ExecutionType : int {
89 Sample_CallChainEntry_ExecutionType_NATIVE_METHOD = 0,
90 Sample_CallChainEntry_ExecutionType_INTERPRETED_JVM_METHOD = 1,
91 Sample_CallChainEntry_ExecutionType_JIT_JVM_METHOD = 2,
92 Sample_CallChainEntry_ExecutionType_ART_METHOD = 3
93 };
94 bool Sample_CallChainEntry_ExecutionType_IsValid(int value);
95 constexpr Sample_CallChainEntry_ExecutionType Sample_CallChainEntry_ExecutionType_ExecutionType_MIN = Sample_CallChainEntry_ExecutionType_NATIVE_METHOD;
96 constexpr Sample_CallChainEntry_ExecutionType Sample_CallChainEntry_ExecutionType_ExecutionType_MAX = Sample_CallChainEntry_ExecutionType_ART_METHOD;
97 constexpr int Sample_CallChainEntry_ExecutionType_ExecutionType_ARRAYSIZE = Sample_CallChainEntry_ExecutionType_ExecutionType_MAX + 1;
98
99 const std::string& Sample_CallChainEntry_ExecutionType_Name(Sample_CallChainEntry_ExecutionType value);
100 template<typename T>
Sample_CallChainEntry_ExecutionType_Name(T enum_t_value)101 inline const std::string& Sample_CallChainEntry_ExecutionType_Name(T enum_t_value) {
102 static_assert(::std::is_same<T, Sample_CallChainEntry_ExecutionType>::value ||
103 ::std::is_integral<T>::value,
104 "Incorrect type passed to function Sample_CallChainEntry_ExecutionType_Name.");
105 return Sample_CallChainEntry_ExecutionType_Name(static_cast<Sample_CallChainEntry_ExecutionType>(enum_t_value));
106 }
107 bool Sample_CallChainEntry_ExecutionType_Parse(
108 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Sample_CallChainEntry_ExecutionType* value);
109 enum Sample_UnwindingResult_ErrorCode : int {
110 Sample_UnwindingResult_ErrorCode_ERROR_NONE = 0,
111 Sample_UnwindingResult_ErrorCode_ERROR_UNKNOWN = 1,
112 Sample_UnwindingResult_ErrorCode_ERROR_NOT_ENOUGH_STACK = 2,
113 Sample_UnwindingResult_ErrorCode_ERROR_MEMORY_INVALID = 3,
114 Sample_UnwindingResult_ErrorCode_ERROR_UNWIND_INFO = 4,
115 Sample_UnwindingResult_ErrorCode_ERROR_INVALID_MAP = 5,
116 Sample_UnwindingResult_ErrorCode_ERROR_MAX_FRAME_EXCEEDED = 6,
117 Sample_UnwindingResult_ErrorCode_ERROR_REPEATED_FRAME = 7,
118 Sample_UnwindingResult_ErrorCode_ERROR_INVALID_ELF = 8
119 };
120 bool Sample_UnwindingResult_ErrorCode_IsValid(int value);
121 constexpr Sample_UnwindingResult_ErrorCode Sample_UnwindingResult_ErrorCode_ErrorCode_MIN = Sample_UnwindingResult_ErrorCode_ERROR_NONE;
122 constexpr Sample_UnwindingResult_ErrorCode Sample_UnwindingResult_ErrorCode_ErrorCode_MAX = Sample_UnwindingResult_ErrorCode_ERROR_INVALID_ELF;
123 constexpr int Sample_UnwindingResult_ErrorCode_ErrorCode_ARRAYSIZE = Sample_UnwindingResult_ErrorCode_ErrorCode_MAX + 1;
124
125 const std::string& Sample_UnwindingResult_ErrorCode_Name(Sample_UnwindingResult_ErrorCode value);
126 template<typename T>
Sample_UnwindingResult_ErrorCode_Name(T enum_t_value)127 inline const std::string& Sample_UnwindingResult_ErrorCode_Name(T enum_t_value) {
128 static_assert(::std::is_same<T, Sample_UnwindingResult_ErrorCode>::value ||
129 ::std::is_integral<T>::value,
130 "Incorrect type passed to function Sample_UnwindingResult_ErrorCode_Name.");
131 return Sample_UnwindingResult_ErrorCode_Name(static_cast<Sample_UnwindingResult_ErrorCode>(enum_t_value));
132 }
133 bool Sample_UnwindingResult_ErrorCode_Parse(
134 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Sample_UnwindingResult_ErrorCode* value);
135 // ===================================================================
136
137 class Sample_CallChainEntry final :
138 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.Sample.CallChainEntry) */ {
139 public:
Sample_CallChainEntry()140 inline Sample_CallChainEntry() : Sample_CallChainEntry(nullptr) {}
141 ~Sample_CallChainEntry() override;
142 explicit PROTOBUF_CONSTEXPR Sample_CallChainEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
143
144 Sample_CallChainEntry(const Sample_CallChainEntry& from);
Sample_CallChainEntry(Sample_CallChainEntry && from)145 Sample_CallChainEntry(Sample_CallChainEntry&& from) noexcept
146 : Sample_CallChainEntry() {
147 *this = ::std::move(from);
148 }
149
150 inline Sample_CallChainEntry& operator=(const Sample_CallChainEntry& from) {
151 if (this == &from) return *this;
152 CopyFrom(from);
153 return *this;
154 }
155 inline Sample_CallChainEntry& operator=(Sample_CallChainEntry&& from) noexcept {
156 if (this == &from) return *this;
157 if (GetOwningArena() == from.GetOwningArena()
158 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
159 && GetOwningArena() != nullptr
160 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
161 ) {
162 InternalSwap(&from);
163 } else {
164 CopyFrom(from);
165 }
166 return *this;
167 }
168
unknown_fields()169 inline const std::string& unknown_fields() const {
170 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
171 }
mutable_unknown_fields()172 inline std::string* mutable_unknown_fields() {
173 return _internal_metadata_.mutable_unknown_fields<std::string>();
174 }
175
default_instance()176 static const Sample_CallChainEntry& default_instance() {
177 return *internal_default_instance();
178 }
internal_default_instance()179 static inline const Sample_CallChainEntry* internal_default_instance() {
180 return reinterpret_cast<const Sample_CallChainEntry*>(
181 &_Sample_CallChainEntry_default_instance_);
182 }
183 static constexpr int kIndexInFileMessages =
184 0;
185
swap(Sample_CallChainEntry & a,Sample_CallChainEntry & b)186 friend void swap(Sample_CallChainEntry& a, Sample_CallChainEntry& b) {
187 a.Swap(&b);
188 }
Swap(Sample_CallChainEntry * other)189 inline void Swap(Sample_CallChainEntry* other) {
190 if (other == this) return;
191 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
192 if (GetOwningArena() != nullptr &&
193 GetOwningArena() == other->GetOwningArena()) {
194 #else // PROTOBUF_FORCE_COPY_IN_SWAP
195 if (GetOwningArena() == other->GetOwningArena()) {
196 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
197 InternalSwap(other);
198 } else {
199 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
200 }
201 }
202 void UnsafeArenaSwap(Sample_CallChainEntry* other) {
203 if (other == this) return;
204 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
205 InternalSwap(other);
206 }
207
208 // implements Message ----------------------------------------------
209
210 Sample_CallChainEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
211 return CreateMaybeMessage<Sample_CallChainEntry>(arena);
212 }
213 Sample_CallChainEntry* New() const {
214 return New(nullptr);
215 }
216 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
217 void CopyFrom(const Sample_CallChainEntry& from);
218 void MergeFrom(const Sample_CallChainEntry& from);
219 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
220 bool IsInitialized() const final;
221
222 size_t ByteSizeLong() const final;
223 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
224 ::uint8_t* _InternalSerialize(
225 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
226 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
227
228 private:
229 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
230 void SharedDtor();
231 void SetCachedSize(int size) const;
232 void InternalSwap(Sample_CallChainEntry* other);
233
234 private:
235 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
236 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
237 return "simpleperf_report_proto.Sample.CallChainEntry";
238 }
239 protected:
240 explicit Sample_CallChainEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
241 bool is_message_owned = false);
242 public:
243
244 std::string GetTypeName() const final;
245
246 // nested types ----------------------------------------------------
247
248 typedef Sample_CallChainEntry_ExecutionType ExecutionType;
249 static constexpr ExecutionType NATIVE_METHOD =
250 Sample_CallChainEntry_ExecutionType_NATIVE_METHOD;
251 static constexpr ExecutionType INTERPRETED_JVM_METHOD =
252 Sample_CallChainEntry_ExecutionType_INTERPRETED_JVM_METHOD;
253 static constexpr ExecutionType JIT_JVM_METHOD =
254 Sample_CallChainEntry_ExecutionType_JIT_JVM_METHOD;
255 static constexpr ExecutionType ART_METHOD =
256 Sample_CallChainEntry_ExecutionType_ART_METHOD;
257 static inline bool ExecutionType_IsValid(int value) {
258 return Sample_CallChainEntry_ExecutionType_IsValid(value);
259 }
260 static constexpr ExecutionType ExecutionType_MIN =
261 Sample_CallChainEntry_ExecutionType_ExecutionType_MIN;
262 static constexpr ExecutionType ExecutionType_MAX =
263 Sample_CallChainEntry_ExecutionType_ExecutionType_MAX;
264 static constexpr int ExecutionType_ARRAYSIZE =
265 Sample_CallChainEntry_ExecutionType_ExecutionType_ARRAYSIZE;
266 template<typename T>
267 static inline const std::string& ExecutionType_Name(T enum_t_value) {
268 static_assert(::std::is_same<T, ExecutionType>::value ||
269 ::std::is_integral<T>::value,
270 "Incorrect type passed to function ExecutionType_Name.");
271 return Sample_CallChainEntry_ExecutionType_Name(enum_t_value);
272 }
273 static inline bool ExecutionType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
274 ExecutionType* value) {
275 return Sample_CallChainEntry_ExecutionType_Parse(name, value);
276 }
277
278 // accessors -------------------------------------------------------
279
280 enum : int {
281 kVaddrInFileFieldNumber = 1,
282 kFileIdFieldNumber = 2,
283 kSymbolIdFieldNumber = 3,
284 kExecutionTypeFieldNumber = 4,
285 };
286 // optional uint64 vaddr_in_file = 1;
287 bool has_vaddr_in_file() const;
288 private:
289 bool _internal_has_vaddr_in_file() const;
290 public:
291 void clear_vaddr_in_file();
292 ::uint64_t vaddr_in_file() const;
293 void set_vaddr_in_file(::uint64_t value);
294 private:
295 ::uint64_t _internal_vaddr_in_file() const;
296 void _internal_set_vaddr_in_file(::uint64_t value);
297 public:
298
299 // optional uint32 file_id = 2;
300 bool has_file_id() const;
301 private:
302 bool _internal_has_file_id() const;
303 public:
304 void clear_file_id();
305 ::uint32_t file_id() const;
306 void set_file_id(::uint32_t value);
307 private:
308 ::uint32_t _internal_file_id() const;
309 void _internal_set_file_id(::uint32_t value);
310 public:
311
312 // optional int32 symbol_id = 3;
313 bool has_symbol_id() const;
314 private:
315 bool _internal_has_symbol_id() const;
316 public:
317 void clear_symbol_id();
318 ::int32_t symbol_id() const;
319 void set_symbol_id(::int32_t value);
320 private:
321 ::int32_t _internal_symbol_id() const;
322 void _internal_set_symbol_id(::int32_t value);
323 public:
324
325 // optional .simpleperf_report_proto.Sample.CallChainEntry.ExecutionType execution_type = 4 [default = NATIVE_METHOD];
326 bool has_execution_type() const;
327 private:
328 bool _internal_has_execution_type() const;
329 public:
330 void clear_execution_type();
331 ::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType execution_type() const;
332 void set_execution_type(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType value);
333 private:
334 ::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType _internal_execution_type() const;
335 void _internal_set_execution_type(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType value);
336 public:
337
338 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.Sample.CallChainEntry)
339 private:
340 class _Internal;
341
342 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
343 typedef void InternalArenaConstructable_;
344 typedef void DestructorSkippable_;
345 struct Impl_ {
346 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
347 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
348 ::uint64_t vaddr_in_file_;
349 ::uint32_t file_id_;
350 ::int32_t symbol_id_;
351 int execution_type_;
352 };
353 union { Impl_ _impl_; };
354 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
355 };
356 // -------------------------------------------------------------------
357
358 class Sample_UnwindingResult final :
359 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.Sample.UnwindingResult) */ {
360 public:
Sample_UnwindingResult()361 inline Sample_UnwindingResult() : Sample_UnwindingResult(nullptr) {}
362 ~Sample_UnwindingResult() override;
363 explicit PROTOBUF_CONSTEXPR Sample_UnwindingResult(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
364
365 Sample_UnwindingResult(const Sample_UnwindingResult& from);
Sample_UnwindingResult(Sample_UnwindingResult && from)366 Sample_UnwindingResult(Sample_UnwindingResult&& from) noexcept
367 : Sample_UnwindingResult() {
368 *this = ::std::move(from);
369 }
370
371 inline Sample_UnwindingResult& operator=(const Sample_UnwindingResult& from) {
372 if (this == &from) return *this;
373 CopyFrom(from);
374 return *this;
375 }
376 inline Sample_UnwindingResult& operator=(Sample_UnwindingResult&& from) noexcept {
377 if (this == &from) return *this;
378 if (GetOwningArena() == from.GetOwningArena()
379 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
380 && GetOwningArena() != nullptr
381 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
382 ) {
383 InternalSwap(&from);
384 } else {
385 CopyFrom(from);
386 }
387 return *this;
388 }
389
unknown_fields()390 inline const std::string& unknown_fields() const {
391 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
392 }
mutable_unknown_fields()393 inline std::string* mutable_unknown_fields() {
394 return _internal_metadata_.mutable_unknown_fields<std::string>();
395 }
396
default_instance()397 static const Sample_UnwindingResult& default_instance() {
398 return *internal_default_instance();
399 }
internal_default_instance()400 static inline const Sample_UnwindingResult* internal_default_instance() {
401 return reinterpret_cast<const Sample_UnwindingResult*>(
402 &_Sample_UnwindingResult_default_instance_);
403 }
404 static constexpr int kIndexInFileMessages =
405 1;
406
swap(Sample_UnwindingResult & a,Sample_UnwindingResult & b)407 friend void swap(Sample_UnwindingResult& a, Sample_UnwindingResult& b) {
408 a.Swap(&b);
409 }
Swap(Sample_UnwindingResult * other)410 inline void Swap(Sample_UnwindingResult* other) {
411 if (other == this) return;
412 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
413 if (GetOwningArena() != nullptr &&
414 GetOwningArena() == other->GetOwningArena()) {
415 #else // PROTOBUF_FORCE_COPY_IN_SWAP
416 if (GetOwningArena() == other->GetOwningArena()) {
417 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
418 InternalSwap(other);
419 } else {
420 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
421 }
422 }
423 void UnsafeArenaSwap(Sample_UnwindingResult* other) {
424 if (other == this) return;
425 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
426 InternalSwap(other);
427 }
428
429 // implements Message ----------------------------------------------
430
431 Sample_UnwindingResult* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
432 return CreateMaybeMessage<Sample_UnwindingResult>(arena);
433 }
434 Sample_UnwindingResult* New() const {
435 return New(nullptr);
436 }
437 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
438 void CopyFrom(const Sample_UnwindingResult& from);
439 void MergeFrom(const Sample_UnwindingResult& from);
440 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
441 bool IsInitialized() const final;
442
443 size_t ByteSizeLong() const final;
444 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
445 ::uint8_t* _InternalSerialize(
446 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
447 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
448
449 private:
450 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
451 void SharedDtor();
452 void SetCachedSize(int size) const;
453 void InternalSwap(Sample_UnwindingResult* other);
454
455 private:
456 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
457 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
458 return "simpleperf_report_proto.Sample.UnwindingResult";
459 }
460 protected:
461 explicit Sample_UnwindingResult(::PROTOBUF_NAMESPACE_ID::Arena* arena,
462 bool is_message_owned = false);
463 public:
464
465 std::string GetTypeName() const final;
466
467 // nested types ----------------------------------------------------
468
469 typedef Sample_UnwindingResult_ErrorCode ErrorCode;
470 static constexpr ErrorCode ERROR_NONE =
471 Sample_UnwindingResult_ErrorCode_ERROR_NONE;
472 static constexpr ErrorCode ERROR_UNKNOWN =
473 Sample_UnwindingResult_ErrorCode_ERROR_UNKNOWN;
474 static constexpr ErrorCode ERROR_NOT_ENOUGH_STACK =
475 Sample_UnwindingResult_ErrorCode_ERROR_NOT_ENOUGH_STACK;
476 static constexpr ErrorCode ERROR_MEMORY_INVALID =
477 Sample_UnwindingResult_ErrorCode_ERROR_MEMORY_INVALID;
478 static constexpr ErrorCode ERROR_UNWIND_INFO =
479 Sample_UnwindingResult_ErrorCode_ERROR_UNWIND_INFO;
480 static constexpr ErrorCode ERROR_INVALID_MAP =
481 Sample_UnwindingResult_ErrorCode_ERROR_INVALID_MAP;
482 static constexpr ErrorCode ERROR_MAX_FRAME_EXCEEDED =
483 Sample_UnwindingResult_ErrorCode_ERROR_MAX_FRAME_EXCEEDED;
484 static constexpr ErrorCode ERROR_REPEATED_FRAME =
485 Sample_UnwindingResult_ErrorCode_ERROR_REPEATED_FRAME;
486 static constexpr ErrorCode ERROR_INVALID_ELF =
487 Sample_UnwindingResult_ErrorCode_ERROR_INVALID_ELF;
488 static inline bool ErrorCode_IsValid(int value) {
489 return Sample_UnwindingResult_ErrorCode_IsValid(value);
490 }
491 static constexpr ErrorCode ErrorCode_MIN =
492 Sample_UnwindingResult_ErrorCode_ErrorCode_MIN;
493 static constexpr ErrorCode ErrorCode_MAX =
494 Sample_UnwindingResult_ErrorCode_ErrorCode_MAX;
495 static constexpr int ErrorCode_ARRAYSIZE =
496 Sample_UnwindingResult_ErrorCode_ErrorCode_ARRAYSIZE;
497 template<typename T>
498 static inline const std::string& ErrorCode_Name(T enum_t_value) {
499 static_assert(::std::is_same<T, ErrorCode>::value ||
500 ::std::is_integral<T>::value,
501 "Incorrect type passed to function ErrorCode_Name.");
502 return Sample_UnwindingResult_ErrorCode_Name(enum_t_value);
503 }
504 static inline bool ErrorCode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
505 ErrorCode* value) {
506 return Sample_UnwindingResult_ErrorCode_Parse(name, value);
507 }
508
509 // accessors -------------------------------------------------------
510
511 enum : int {
512 kErrorAddrFieldNumber = 2,
513 kRawErrorCodeFieldNumber = 1,
514 kErrorCodeFieldNumber = 3,
515 };
516 // optional uint64 error_addr = 2;
517 bool has_error_addr() const;
518 private:
519 bool _internal_has_error_addr() const;
520 public:
521 void clear_error_addr();
522 ::uint64_t error_addr() const;
523 void set_error_addr(::uint64_t value);
524 private:
525 ::uint64_t _internal_error_addr() const;
526 void _internal_set_error_addr(::uint64_t value);
527 public:
528
529 // optional uint32 raw_error_code = 1;
530 bool has_raw_error_code() const;
531 private:
532 bool _internal_has_raw_error_code() const;
533 public:
534 void clear_raw_error_code();
535 ::uint32_t raw_error_code() const;
536 void set_raw_error_code(::uint32_t value);
537 private:
538 ::uint32_t _internal_raw_error_code() const;
539 void _internal_set_raw_error_code(::uint32_t value);
540 public:
541
542 // optional .simpleperf_report_proto.Sample.UnwindingResult.ErrorCode error_code = 3;
543 bool has_error_code() const;
544 private:
545 bool _internal_has_error_code() const;
546 public:
547 void clear_error_code();
548 ::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode error_code() const;
549 void set_error_code(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode value);
550 private:
551 ::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode _internal_error_code() const;
552 void _internal_set_error_code(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode value);
553 public:
554
555 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.Sample.UnwindingResult)
556 private:
557 class _Internal;
558
559 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
560 typedef void InternalArenaConstructable_;
561 typedef void DestructorSkippable_;
562 struct Impl_ {
563 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
564 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
565 ::uint64_t error_addr_;
566 ::uint32_t raw_error_code_;
567 int error_code_;
568 };
569 union { Impl_ _impl_; };
570 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
571 };
572 // -------------------------------------------------------------------
573
574 class Sample final :
575 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.Sample) */ {
576 public:
Sample()577 inline Sample() : Sample(nullptr) {}
578 ~Sample() override;
579 explicit PROTOBUF_CONSTEXPR Sample(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
580
581 Sample(const Sample& from);
Sample(Sample && from)582 Sample(Sample&& from) noexcept
583 : Sample() {
584 *this = ::std::move(from);
585 }
586
587 inline Sample& operator=(const Sample& from) {
588 if (this == &from) return *this;
589 CopyFrom(from);
590 return *this;
591 }
592 inline Sample& operator=(Sample&& from) noexcept {
593 if (this == &from) return *this;
594 if (GetOwningArena() == from.GetOwningArena()
595 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
596 && GetOwningArena() != nullptr
597 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
598 ) {
599 InternalSwap(&from);
600 } else {
601 CopyFrom(from);
602 }
603 return *this;
604 }
605
unknown_fields()606 inline const std::string& unknown_fields() const {
607 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
608 }
mutable_unknown_fields()609 inline std::string* mutable_unknown_fields() {
610 return _internal_metadata_.mutable_unknown_fields<std::string>();
611 }
612
default_instance()613 static const Sample& default_instance() {
614 return *internal_default_instance();
615 }
internal_default_instance()616 static inline const Sample* internal_default_instance() {
617 return reinterpret_cast<const Sample*>(
618 &_Sample_default_instance_);
619 }
620 static constexpr int kIndexInFileMessages =
621 2;
622
swap(Sample & a,Sample & b)623 friend void swap(Sample& a, Sample& b) {
624 a.Swap(&b);
625 }
Swap(Sample * other)626 inline void Swap(Sample* other) {
627 if (other == this) return;
628 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
629 if (GetOwningArena() != nullptr &&
630 GetOwningArena() == other->GetOwningArena()) {
631 #else // PROTOBUF_FORCE_COPY_IN_SWAP
632 if (GetOwningArena() == other->GetOwningArena()) {
633 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
634 InternalSwap(other);
635 } else {
636 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
637 }
638 }
639 void UnsafeArenaSwap(Sample* other) {
640 if (other == this) return;
641 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
642 InternalSwap(other);
643 }
644
645 // implements Message ----------------------------------------------
646
647 Sample* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
648 return CreateMaybeMessage<Sample>(arena);
649 }
650 Sample* New() const {
651 return New(nullptr);
652 }
653 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
654 void CopyFrom(const Sample& from);
655 void MergeFrom(const Sample& from);
656 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
657 bool IsInitialized() const final;
658
659 size_t ByteSizeLong() const final;
660 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
661 ::uint8_t* _InternalSerialize(
662 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
663 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
664
665 private:
666 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
667 void SharedDtor();
668 void SetCachedSize(int size) const;
669 void InternalSwap(Sample* other);
670
671 private:
672 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
673 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
674 return "simpleperf_report_proto.Sample";
675 }
676 protected:
677 explicit Sample(::PROTOBUF_NAMESPACE_ID::Arena* arena,
678 bool is_message_owned = false);
679 public:
680
681 std::string GetTypeName() const final;
682
683 // nested types ----------------------------------------------------
684
685 typedef Sample_CallChainEntry CallChainEntry;
686 typedef Sample_UnwindingResult UnwindingResult;
687
688 // accessors -------------------------------------------------------
689
690 enum : int {
691 kCallchainFieldNumber = 3,
692 kUnwindingResultFieldNumber = 6,
693 kTimeFieldNumber = 1,
694 kThreadIdFieldNumber = 2,
695 kEventTypeIdFieldNumber = 5,
696 kEventCountFieldNumber = 4,
697 };
698 // repeated .simpleperf_report_proto.Sample.CallChainEntry callchain = 3;
699 int callchain_size() const;
700 private:
701 int _internal_callchain_size() const;
702 public:
703 void clear_callchain();
704 ::simpleperf_report_proto::Sample_CallChainEntry* mutable_callchain(int index);
705 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::simpleperf_report_proto::Sample_CallChainEntry >*
706 mutable_callchain();
707 private:
708 const ::simpleperf_report_proto::Sample_CallChainEntry& _internal_callchain(int index) const;
709 ::simpleperf_report_proto::Sample_CallChainEntry* _internal_add_callchain();
710 public:
711 const ::simpleperf_report_proto::Sample_CallChainEntry& callchain(int index) const;
712 ::simpleperf_report_proto::Sample_CallChainEntry* add_callchain();
713 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::simpleperf_report_proto::Sample_CallChainEntry >&
714 callchain() const;
715
716 // optional .simpleperf_report_proto.Sample.UnwindingResult unwinding_result = 6;
717 bool has_unwinding_result() const;
718 private:
719 bool _internal_has_unwinding_result() const;
720 public:
721 void clear_unwinding_result();
722 const ::simpleperf_report_proto::Sample_UnwindingResult& unwinding_result() const;
723 PROTOBUF_NODISCARD ::simpleperf_report_proto::Sample_UnwindingResult* release_unwinding_result();
724 ::simpleperf_report_proto::Sample_UnwindingResult* mutable_unwinding_result();
725 void set_allocated_unwinding_result(::simpleperf_report_proto::Sample_UnwindingResult* unwinding_result);
726 private:
727 const ::simpleperf_report_proto::Sample_UnwindingResult& _internal_unwinding_result() const;
728 ::simpleperf_report_proto::Sample_UnwindingResult* _internal_mutable_unwinding_result();
729 public:
730 void unsafe_arena_set_allocated_unwinding_result(
731 ::simpleperf_report_proto::Sample_UnwindingResult* unwinding_result);
732 ::simpleperf_report_proto::Sample_UnwindingResult* unsafe_arena_release_unwinding_result();
733
734 // optional uint64 time = 1;
735 bool has_time() const;
736 private:
737 bool _internal_has_time() const;
738 public:
739 void clear_time();
740 ::uint64_t time() const;
741 void set_time(::uint64_t value);
742 private:
743 ::uint64_t _internal_time() const;
744 void _internal_set_time(::uint64_t value);
745 public:
746
747 // optional int32 thread_id = 2;
748 bool has_thread_id() const;
749 private:
750 bool _internal_has_thread_id() const;
751 public:
752 void clear_thread_id();
753 ::int32_t thread_id() const;
754 void set_thread_id(::int32_t value);
755 private:
756 ::int32_t _internal_thread_id() const;
757 void _internal_set_thread_id(::int32_t value);
758 public:
759
760 // optional uint32 event_type_id = 5;
761 bool has_event_type_id() const;
762 private:
763 bool _internal_has_event_type_id() const;
764 public:
765 void clear_event_type_id();
766 ::uint32_t event_type_id() const;
767 void set_event_type_id(::uint32_t value);
768 private:
769 ::uint32_t _internal_event_type_id() const;
770 void _internal_set_event_type_id(::uint32_t value);
771 public:
772
773 // optional uint64 event_count = 4;
774 bool has_event_count() const;
775 private:
776 bool _internal_has_event_count() const;
777 public:
778 void clear_event_count();
779 ::uint64_t event_count() const;
780 void set_event_count(::uint64_t value);
781 private:
782 ::uint64_t _internal_event_count() const;
783 void _internal_set_event_count(::uint64_t value);
784 public:
785
786 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.Sample)
787 private:
788 class _Internal;
789
790 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
791 typedef void InternalArenaConstructable_;
792 typedef void DestructorSkippable_;
793 struct Impl_ {
794 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
795 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
796 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::simpleperf_report_proto::Sample_CallChainEntry > callchain_;
797 ::simpleperf_report_proto::Sample_UnwindingResult* unwinding_result_;
798 ::uint64_t time_;
799 ::int32_t thread_id_;
800 ::uint32_t event_type_id_;
801 ::uint64_t event_count_;
802 };
803 union { Impl_ _impl_; };
804 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
805 };
806 // -------------------------------------------------------------------
807
808 class LostSituation final :
809 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.LostSituation) */ {
810 public:
LostSituation()811 inline LostSituation() : LostSituation(nullptr) {}
812 ~LostSituation() override;
813 explicit PROTOBUF_CONSTEXPR LostSituation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
814
815 LostSituation(const LostSituation& from);
LostSituation(LostSituation && from)816 LostSituation(LostSituation&& from) noexcept
817 : LostSituation() {
818 *this = ::std::move(from);
819 }
820
821 inline LostSituation& operator=(const LostSituation& from) {
822 if (this == &from) return *this;
823 CopyFrom(from);
824 return *this;
825 }
826 inline LostSituation& operator=(LostSituation&& from) noexcept {
827 if (this == &from) return *this;
828 if (GetOwningArena() == from.GetOwningArena()
829 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
830 && GetOwningArena() != nullptr
831 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
832 ) {
833 InternalSwap(&from);
834 } else {
835 CopyFrom(from);
836 }
837 return *this;
838 }
839
unknown_fields()840 inline const std::string& unknown_fields() const {
841 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
842 }
mutable_unknown_fields()843 inline std::string* mutable_unknown_fields() {
844 return _internal_metadata_.mutable_unknown_fields<std::string>();
845 }
846
default_instance()847 static const LostSituation& default_instance() {
848 return *internal_default_instance();
849 }
internal_default_instance()850 static inline const LostSituation* internal_default_instance() {
851 return reinterpret_cast<const LostSituation*>(
852 &_LostSituation_default_instance_);
853 }
854 static constexpr int kIndexInFileMessages =
855 3;
856
swap(LostSituation & a,LostSituation & b)857 friend void swap(LostSituation& a, LostSituation& b) {
858 a.Swap(&b);
859 }
Swap(LostSituation * other)860 inline void Swap(LostSituation* other) {
861 if (other == this) return;
862 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
863 if (GetOwningArena() != nullptr &&
864 GetOwningArena() == other->GetOwningArena()) {
865 #else // PROTOBUF_FORCE_COPY_IN_SWAP
866 if (GetOwningArena() == other->GetOwningArena()) {
867 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
868 InternalSwap(other);
869 } else {
870 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
871 }
872 }
873 void UnsafeArenaSwap(LostSituation* other) {
874 if (other == this) return;
875 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
876 InternalSwap(other);
877 }
878
879 // implements Message ----------------------------------------------
880
881 LostSituation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
882 return CreateMaybeMessage<LostSituation>(arena);
883 }
884 LostSituation* New() const {
885 return New(nullptr);
886 }
887 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
888 void CopyFrom(const LostSituation& from);
889 void MergeFrom(const LostSituation& from);
890 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
891 bool IsInitialized() const final;
892
893 size_t ByteSizeLong() const final;
894 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
895 ::uint8_t* _InternalSerialize(
896 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
897 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
898
899 private:
900 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
901 void SharedDtor();
902 void SetCachedSize(int size) const;
903 void InternalSwap(LostSituation* other);
904
905 private:
906 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
907 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
908 return "simpleperf_report_proto.LostSituation";
909 }
910 protected:
911 explicit LostSituation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
912 bool is_message_owned = false);
913 public:
914
915 std::string GetTypeName() const final;
916
917 // nested types ----------------------------------------------------
918
919 // accessors -------------------------------------------------------
920
921 enum : int {
922 kSampleCountFieldNumber = 1,
923 kLostCountFieldNumber = 2,
924 };
925 // optional uint64 sample_count = 1;
926 bool has_sample_count() const;
927 private:
928 bool _internal_has_sample_count() const;
929 public:
930 void clear_sample_count();
931 ::uint64_t sample_count() const;
932 void set_sample_count(::uint64_t value);
933 private:
934 ::uint64_t _internal_sample_count() const;
935 void _internal_set_sample_count(::uint64_t value);
936 public:
937
938 // optional uint64 lost_count = 2;
939 bool has_lost_count() const;
940 private:
941 bool _internal_has_lost_count() const;
942 public:
943 void clear_lost_count();
944 ::uint64_t lost_count() const;
945 void set_lost_count(::uint64_t value);
946 private:
947 ::uint64_t _internal_lost_count() const;
948 void _internal_set_lost_count(::uint64_t value);
949 public:
950
951 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.LostSituation)
952 private:
953 class _Internal;
954
955 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
956 typedef void InternalArenaConstructable_;
957 typedef void DestructorSkippable_;
958 struct Impl_ {
959 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
960 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
961 ::uint64_t sample_count_;
962 ::uint64_t lost_count_;
963 };
964 union { Impl_ _impl_; };
965 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
966 };
967 // -------------------------------------------------------------------
968
969 class File final :
970 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.File) */ {
971 public:
File()972 inline File() : File(nullptr) {}
973 ~File() override;
974 explicit PROTOBUF_CONSTEXPR File(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
975
976 File(const File& from);
File(File && from)977 File(File&& from) noexcept
978 : File() {
979 *this = ::std::move(from);
980 }
981
982 inline File& operator=(const File& from) {
983 if (this == &from) return *this;
984 CopyFrom(from);
985 return *this;
986 }
987 inline File& operator=(File&& from) noexcept {
988 if (this == &from) return *this;
989 if (GetOwningArena() == from.GetOwningArena()
990 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
991 && GetOwningArena() != nullptr
992 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
993 ) {
994 InternalSwap(&from);
995 } else {
996 CopyFrom(from);
997 }
998 return *this;
999 }
1000
unknown_fields()1001 inline const std::string& unknown_fields() const {
1002 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1003 }
mutable_unknown_fields()1004 inline std::string* mutable_unknown_fields() {
1005 return _internal_metadata_.mutable_unknown_fields<std::string>();
1006 }
1007
default_instance()1008 static const File& default_instance() {
1009 return *internal_default_instance();
1010 }
internal_default_instance()1011 static inline const File* internal_default_instance() {
1012 return reinterpret_cast<const File*>(
1013 &_File_default_instance_);
1014 }
1015 static constexpr int kIndexInFileMessages =
1016 4;
1017
swap(File & a,File & b)1018 friend void swap(File& a, File& b) {
1019 a.Swap(&b);
1020 }
Swap(File * other)1021 inline void Swap(File* other) {
1022 if (other == this) return;
1023 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1024 if (GetOwningArena() != nullptr &&
1025 GetOwningArena() == other->GetOwningArena()) {
1026 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1027 if (GetOwningArena() == other->GetOwningArena()) {
1028 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1029 InternalSwap(other);
1030 } else {
1031 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1032 }
1033 }
1034 void UnsafeArenaSwap(File* other) {
1035 if (other == this) return;
1036 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1037 InternalSwap(other);
1038 }
1039
1040 // implements Message ----------------------------------------------
1041
1042 File* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1043 return CreateMaybeMessage<File>(arena);
1044 }
1045 File* New() const {
1046 return New(nullptr);
1047 }
1048 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1049 void CopyFrom(const File& from);
1050 void MergeFrom(const File& from);
1051 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1052 bool IsInitialized() const final;
1053
1054 size_t ByteSizeLong() const final;
1055 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1056 ::uint8_t* _InternalSerialize(
1057 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1058 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1059
1060 private:
1061 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1062 void SharedDtor();
1063 void SetCachedSize(int size) const;
1064 void InternalSwap(File* other);
1065
1066 private:
1067 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1068 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1069 return "simpleperf_report_proto.File";
1070 }
1071 protected:
1072 explicit File(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1073 bool is_message_owned = false);
1074 public:
1075
1076 std::string GetTypeName() const final;
1077
1078 // nested types ----------------------------------------------------
1079
1080 // accessors -------------------------------------------------------
1081
1082 enum : int {
1083 kSymbolFieldNumber = 3,
1084 kMangledSymbolFieldNumber = 4,
1085 kPathFieldNumber = 2,
1086 kIdFieldNumber = 1,
1087 };
1088 // repeated string symbol = 3;
1089 int symbol_size() const;
1090 private:
1091 int _internal_symbol_size() const;
1092 public:
1093 void clear_symbol();
1094 const std::string& symbol(int index) const;
1095 std::string* mutable_symbol(int index);
1096 void set_symbol(int index, const std::string& value);
1097 void set_symbol(int index, std::string&& value);
1098 void set_symbol(int index, const char* value);
1099 void set_symbol(int index, const char* value, size_t size);
1100 std::string* add_symbol();
1101 void add_symbol(const std::string& value);
1102 void add_symbol(std::string&& value);
1103 void add_symbol(const char* value);
1104 void add_symbol(const char* value, size_t size);
1105 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& symbol() const;
1106 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_symbol();
1107 private:
1108 const std::string& _internal_symbol(int index) const;
1109 std::string* _internal_add_symbol();
1110 public:
1111
1112 // repeated string mangled_symbol = 4;
1113 int mangled_symbol_size() const;
1114 private:
1115 int _internal_mangled_symbol_size() const;
1116 public:
1117 void clear_mangled_symbol();
1118 const std::string& mangled_symbol(int index) const;
1119 std::string* mutable_mangled_symbol(int index);
1120 void set_mangled_symbol(int index, const std::string& value);
1121 void set_mangled_symbol(int index, std::string&& value);
1122 void set_mangled_symbol(int index, const char* value);
1123 void set_mangled_symbol(int index, const char* value, size_t size);
1124 std::string* add_mangled_symbol();
1125 void add_mangled_symbol(const std::string& value);
1126 void add_mangled_symbol(std::string&& value);
1127 void add_mangled_symbol(const char* value);
1128 void add_mangled_symbol(const char* value, size_t size);
1129 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& mangled_symbol() const;
1130 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_mangled_symbol();
1131 private:
1132 const std::string& _internal_mangled_symbol(int index) const;
1133 std::string* _internal_add_mangled_symbol();
1134 public:
1135
1136 // optional string path = 2;
1137 bool has_path() const;
1138 private:
1139 bool _internal_has_path() const;
1140 public:
1141 void clear_path();
1142 const std::string& path() const;
1143 template <typename ArgT0 = const std::string&, typename... ArgT>
1144 void set_path(ArgT0&& arg0, ArgT... args);
1145 std::string* mutable_path();
1146 PROTOBUF_NODISCARD std::string* release_path();
1147 void set_allocated_path(std::string* path);
1148 private:
1149 const std::string& _internal_path() const;
1150 inline PROTOBUF_ALWAYS_INLINE void _internal_set_path(const std::string& value);
1151 std::string* _internal_mutable_path();
1152 public:
1153
1154 // optional uint32 id = 1;
1155 bool has_id() const;
1156 private:
1157 bool _internal_has_id() const;
1158 public:
1159 void clear_id();
1160 ::uint32_t id() const;
1161 void set_id(::uint32_t value);
1162 private:
1163 ::uint32_t _internal_id() const;
1164 void _internal_set_id(::uint32_t value);
1165 public:
1166
1167 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.File)
1168 private:
1169 class _Internal;
1170
1171 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1172 typedef void InternalArenaConstructable_;
1173 typedef void DestructorSkippable_;
1174 struct Impl_ {
1175 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1176 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1177 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> symbol_;
1178 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> mangled_symbol_;
1179 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
1180 ::uint32_t id_;
1181 };
1182 union { Impl_ _impl_; };
1183 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
1184 };
1185 // -------------------------------------------------------------------
1186
1187 class Thread final :
1188 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.Thread) */ {
1189 public:
Thread()1190 inline Thread() : Thread(nullptr) {}
1191 ~Thread() override;
1192 explicit PROTOBUF_CONSTEXPR Thread(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1193
1194 Thread(const Thread& from);
Thread(Thread && from)1195 Thread(Thread&& from) noexcept
1196 : Thread() {
1197 *this = ::std::move(from);
1198 }
1199
1200 inline Thread& operator=(const Thread& from) {
1201 if (this == &from) return *this;
1202 CopyFrom(from);
1203 return *this;
1204 }
1205 inline Thread& operator=(Thread&& from) noexcept {
1206 if (this == &from) return *this;
1207 if (GetOwningArena() == from.GetOwningArena()
1208 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1209 && GetOwningArena() != nullptr
1210 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1211 ) {
1212 InternalSwap(&from);
1213 } else {
1214 CopyFrom(from);
1215 }
1216 return *this;
1217 }
1218
unknown_fields()1219 inline const std::string& unknown_fields() const {
1220 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1221 }
mutable_unknown_fields()1222 inline std::string* mutable_unknown_fields() {
1223 return _internal_metadata_.mutable_unknown_fields<std::string>();
1224 }
1225
default_instance()1226 static const Thread& default_instance() {
1227 return *internal_default_instance();
1228 }
internal_default_instance()1229 static inline const Thread* internal_default_instance() {
1230 return reinterpret_cast<const Thread*>(
1231 &_Thread_default_instance_);
1232 }
1233 static constexpr int kIndexInFileMessages =
1234 5;
1235
swap(Thread & a,Thread & b)1236 friend void swap(Thread& a, Thread& b) {
1237 a.Swap(&b);
1238 }
Swap(Thread * other)1239 inline void Swap(Thread* other) {
1240 if (other == this) return;
1241 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1242 if (GetOwningArena() != nullptr &&
1243 GetOwningArena() == other->GetOwningArena()) {
1244 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1245 if (GetOwningArena() == other->GetOwningArena()) {
1246 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1247 InternalSwap(other);
1248 } else {
1249 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1250 }
1251 }
1252 void UnsafeArenaSwap(Thread* other) {
1253 if (other == this) return;
1254 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1255 InternalSwap(other);
1256 }
1257
1258 // implements Message ----------------------------------------------
1259
1260 Thread* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1261 return CreateMaybeMessage<Thread>(arena);
1262 }
1263 Thread* New() const {
1264 return New(nullptr);
1265 }
1266 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1267 void CopyFrom(const Thread& from);
1268 void MergeFrom(const Thread& from);
1269 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1270 bool IsInitialized() const final;
1271
1272 size_t ByteSizeLong() const final;
1273 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1274 ::uint8_t* _InternalSerialize(
1275 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1276 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1277
1278 private:
1279 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1280 void SharedDtor();
1281 void SetCachedSize(int size) const;
1282 void InternalSwap(Thread* other);
1283
1284 private:
1285 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1286 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1287 return "simpleperf_report_proto.Thread";
1288 }
1289 protected:
1290 explicit Thread(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1291 bool is_message_owned = false);
1292 public:
1293
1294 std::string GetTypeName() const final;
1295
1296 // nested types ----------------------------------------------------
1297
1298 // accessors -------------------------------------------------------
1299
1300 enum : int {
1301 kThreadNameFieldNumber = 3,
1302 kThreadIdFieldNumber = 1,
1303 kProcessIdFieldNumber = 2,
1304 };
1305 // optional string thread_name = 3;
1306 bool has_thread_name() const;
1307 private:
1308 bool _internal_has_thread_name() const;
1309 public:
1310 void clear_thread_name();
1311 const std::string& thread_name() const;
1312 template <typename ArgT0 = const std::string&, typename... ArgT>
1313 void set_thread_name(ArgT0&& arg0, ArgT... args);
1314 std::string* mutable_thread_name();
1315 PROTOBUF_NODISCARD std::string* release_thread_name();
1316 void set_allocated_thread_name(std::string* thread_name);
1317 private:
1318 const std::string& _internal_thread_name() const;
1319 inline PROTOBUF_ALWAYS_INLINE void _internal_set_thread_name(const std::string& value);
1320 std::string* _internal_mutable_thread_name();
1321 public:
1322
1323 // optional uint32 thread_id = 1;
1324 bool has_thread_id() const;
1325 private:
1326 bool _internal_has_thread_id() const;
1327 public:
1328 void clear_thread_id();
1329 ::uint32_t thread_id() const;
1330 void set_thread_id(::uint32_t value);
1331 private:
1332 ::uint32_t _internal_thread_id() const;
1333 void _internal_set_thread_id(::uint32_t value);
1334 public:
1335
1336 // optional uint32 process_id = 2;
1337 bool has_process_id() const;
1338 private:
1339 bool _internal_has_process_id() const;
1340 public:
1341 void clear_process_id();
1342 ::uint32_t process_id() const;
1343 void set_process_id(::uint32_t value);
1344 private:
1345 ::uint32_t _internal_process_id() const;
1346 void _internal_set_process_id(::uint32_t value);
1347 public:
1348
1349 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.Thread)
1350 private:
1351 class _Internal;
1352
1353 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1354 typedef void InternalArenaConstructable_;
1355 typedef void DestructorSkippable_;
1356 struct Impl_ {
1357 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1358 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1359 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr thread_name_;
1360 ::uint32_t thread_id_;
1361 ::uint32_t process_id_;
1362 };
1363 union { Impl_ _impl_; };
1364 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
1365 };
1366 // -------------------------------------------------------------------
1367
1368 class MetaInfo final :
1369 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.MetaInfo) */ {
1370 public:
MetaInfo()1371 inline MetaInfo() : MetaInfo(nullptr) {}
1372 ~MetaInfo() override;
1373 explicit PROTOBUF_CONSTEXPR MetaInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1374
1375 MetaInfo(const MetaInfo& from);
MetaInfo(MetaInfo && from)1376 MetaInfo(MetaInfo&& from) noexcept
1377 : MetaInfo() {
1378 *this = ::std::move(from);
1379 }
1380
1381 inline MetaInfo& operator=(const MetaInfo& from) {
1382 if (this == &from) return *this;
1383 CopyFrom(from);
1384 return *this;
1385 }
1386 inline MetaInfo& operator=(MetaInfo&& from) noexcept {
1387 if (this == &from) return *this;
1388 if (GetOwningArena() == from.GetOwningArena()
1389 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1390 && GetOwningArena() != nullptr
1391 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1392 ) {
1393 InternalSwap(&from);
1394 } else {
1395 CopyFrom(from);
1396 }
1397 return *this;
1398 }
1399
unknown_fields()1400 inline const std::string& unknown_fields() const {
1401 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1402 }
mutable_unknown_fields()1403 inline std::string* mutable_unknown_fields() {
1404 return _internal_metadata_.mutable_unknown_fields<std::string>();
1405 }
1406
default_instance()1407 static const MetaInfo& default_instance() {
1408 return *internal_default_instance();
1409 }
internal_default_instance()1410 static inline const MetaInfo* internal_default_instance() {
1411 return reinterpret_cast<const MetaInfo*>(
1412 &_MetaInfo_default_instance_);
1413 }
1414 static constexpr int kIndexInFileMessages =
1415 6;
1416
swap(MetaInfo & a,MetaInfo & b)1417 friend void swap(MetaInfo& a, MetaInfo& b) {
1418 a.Swap(&b);
1419 }
Swap(MetaInfo * other)1420 inline void Swap(MetaInfo* other) {
1421 if (other == this) return;
1422 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1423 if (GetOwningArena() != nullptr &&
1424 GetOwningArena() == other->GetOwningArena()) {
1425 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1426 if (GetOwningArena() == other->GetOwningArena()) {
1427 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1428 InternalSwap(other);
1429 } else {
1430 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1431 }
1432 }
1433 void UnsafeArenaSwap(MetaInfo* other) {
1434 if (other == this) return;
1435 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1436 InternalSwap(other);
1437 }
1438
1439 // implements Message ----------------------------------------------
1440
1441 MetaInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1442 return CreateMaybeMessage<MetaInfo>(arena);
1443 }
1444 MetaInfo* New() const {
1445 return New(nullptr);
1446 }
1447 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1448 void CopyFrom(const MetaInfo& from);
1449 void MergeFrom(const MetaInfo& from);
1450 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1451 bool IsInitialized() const final;
1452
1453 size_t ByteSizeLong() const final;
1454 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1455 ::uint8_t* _InternalSerialize(
1456 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1457 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1458
1459 private:
1460 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1461 void SharedDtor();
1462 void SetCachedSize(int size) const;
1463 void InternalSwap(MetaInfo* other);
1464
1465 private:
1466 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1467 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1468 return "simpleperf_report_proto.MetaInfo";
1469 }
1470 protected:
1471 explicit MetaInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1472 bool is_message_owned = false);
1473 public:
1474
1475 std::string GetTypeName() const final;
1476
1477 // nested types ----------------------------------------------------
1478
1479 // accessors -------------------------------------------------------
1480
1481 enum : int {
1482 kEventTypeFieldNumber = 1,
1483 kAppPackageNameFieldNumber = 2,
1484 kAppTypeFieldNumber = 3,
1485 kAndroidSdkVersionFieldNumber = 4,
1486 kAndroidBuildTypeFieldNumber = 5,
1487 kTraceOffcpuFieldNumber = 6,
1488 };
1489 // repeated string event_type = 1;
1490 int event_type_size() const;
1491 private:
1492 int _internal_event_type_size() const;
1493 public:
1494 void clear_event_type();
1495 const std::string& event_type(int index) const;
1496 std::string* mutable_event_type(int index);
1497 void set_event_type(int index, const std::string& value);
1498 void set_event_type(int index, std::string&& value);
1499 void set_event_type(int index, const char* value);
1500 void set_event_type(int index, const char* value, size_t size);
1501 std::string* add_event_type();
1502 void add_event_type(const std::string& value);
1503 void add_event_type(std::string&& value);
1504 void add_event_type(const char* value);
1505 void add_event_type(const char* value, size_t size);
1506 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& event_type() const;
1507 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_event_type();
1508 private:
1509 const std::string& _internal_event_type(int index) const;
1510 std::string* _internal_add_event_type();
1511 public:
1512
1513 // optional string app_package_name = 2;
1514 bool has_app_package_name() const;
1515 private:
1516 bool _internal_has_app_package_name() const;
1517 public:
1518 void clear_app_package_name();
1519 const std::string& app_package_name() const;
1520 template <typename ArgT0 = const std::string&, typename... ArgT>
1521 void set_app_package_name(ArgT0&& arg0, ArgT... args);
1522 std::string* mutable_app_package_name();
1523 PROTOBUF_NODISCARD std::string* release_app_package_name();
1524 void set_allocated_app_package_name(std::string* app_package_name);
1525 private:
1526 const std::string& _internal_app_package_name() const;
1527 inline PROTOBUF_ALWAYS_INLINE void _internal_set_app_package_name(const std::string& value);
1528 std::string* _internal_mutable_app_package_name();
1529 public:
1530
1531 // optional string app_type = 3;
1532 bool has_app_type() const;
1533 private:
1534 bool _internal_has_app_type() const;
1535 public:
1536 void clear_app_type();
1537 const std::string& app_type() const;
1538 template <typename ArgT0 = const std::string&, typename... ArgT>
1539 void set_app_type(ArgT0&& arg0, ArgT... args);
1540 std::string* mutable_app_type();
1541 PROTOBUF_NODISCARD std::string* release_app_type();
1542 void set_allocated_app_type(std::string* app_type);
1543 private:
1544 const std::string& _internal_app_type() const;
1545 inline PROTOBUF_ALWAYS_INLINE void _internal_set_app_type(const std::string& value);
1546 std::string* _internal_mutable_app_type();
1547 public:
1548
1549 // optional string android_sdk_version = 4;
1550 bool has_android_sdk_version() const;
1551 private:
1552 bool _internal_has_android_sdk_version() const;
1553 public:
1554 void clear_android_sdk_version();
1555 const std::string& android_sdk_version() const;
1556 template <typename ArgT0 = const std::string&, typename... ArgT>
1557 void set_android_sdk_version(ArgT0&& arg0, ArgT... args);
1558 std::string* mutable_android_sdk_version();
1559 PROTOBUF_NODISCARD std::string* release_android_sdk_version();
1560 void set_allocated_android_sdk_version(std::string* android_sdk_version);
1561 private:
1562 const std::string& _internal_android_sdk_version() const;
1563 inline PROTOBUF_ALWAYS_INLINE void _internal_set_android_sdk_version(const std::string& value);
1564 std::string* _internal_mutable_android_sdk_version();
1565 public:
1566
1567 // optional string android_build_type = 5;
1568 bool has_android_build_type() const;
1569 private:
1570 bool _internal_has_android_build_type() const;
1571 public:
1572 void clear_android_build_type();
1573 const std::string& android_build_type() const;
1574 template <typename ArgT0 = const std::string&, typename... ArgT>
1575 void set_android_build_type(ArgT0&& arg0, ArgT... args);
1576 std::string* mutable_android_build_type();
1577 PROTOBUF_NODISCARD std::string* release_android_build_type();
1578 void set_allocated_android_build_type(std::string* android_build_type);
1579 private:
1580 const std::string& _internal_android_build_type() const;
1581 inline PROTOBUF_ALWAYS_INLINE void _internal_set_android_build_type(const std::string& value);
1582 std::string* _internal_mutable_android_build_type();
1583 public:
1584
1585 // optional bool trace_offcpu = 6;
1586 bool has_trace_offcpu() const;
1587 private:
1588 bool _internal_has_trace_offcpu() const;
1589 public:
1590 void clear_trace_offcpu();
1591 bool trace_offcpu() const;
1592 void set_trace_offcpu(bool value);
1593 private:
1594 bool _internal_trace_offcpu() const;
1595 void _internal_set_trace_offcpu(bool value);
1596 public:
1597
1598 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.MetaInfo)
1599 private:
1600 class _Internal;
1601
1602 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1603 typedef void InternalArenaConstructable_;
1604 typedef void DestructorSkippable_;
1605 struct Impl_ {
1606 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1607 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1608 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> event_type_;
1609 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr app_package_name_;
1610 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr app_type_;
1611 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr android_sdk_version_;
1612 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr android_build_type_;
1613 bool trace_offcpu_;
1614 };
1615 union { Impl_ _impl_; };
1616 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
1617 };
1618 // -------------------------------------------------------------------
1619
1620 class ContextSwitch final :
1621 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.ContextSwitch) */ {
1622 public:
ContextSwitch()1623 inline ContextSwitch() : ContextSwitch(nullptr) {}
1624 ~ContextSwitch() override;
1625 explicit PROTOBUF_CONSTEXPR ContextSwitch(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1626
1627 ContextSwitch(const ContextSwitch& from);
ContextSwitch(ContextSwitch && from)1628 ContextSwitch(ContextSwitch&& from) noexcept
1629 : ContextSwitch() {
1630 *this = ::std::move(from);
1631 }
1632
1633 inline ContextSwitch& operator=(const ContextSwitch& from) {
1634 if (this == &from) return *this;
1635 CopyFrom(from);
1636 return *this;
1637 }
1638 inline ContextSwitch& operator=(ContextSwitch&& from) noexcept {
1639 if (this == &from) return *this;
1640 if (GetOwningArena() == from.GetOwningArena()
1641 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1642 && GetOwningArena() != nullptr
1643 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1644 ) {
1645 InternalSwap(&from);
1646 } else {
1647 CopyFrom(from);
1648 }
1649 return *this;
1650 }
1651
unknown_fields()1652 inline const std::string& unknown_fields() const {
1653 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1654 }
mutable_unknown_fields()1655 inline std::string* mutable_unknown_fields() {
1656 return _internal_metadata_.mutable_unknown_fields<std::string>();
1657 }
1658
default_instance()1659 static const ContextSwitch& default_instance() {
1660 return *internal_default_instance();
1661 }
internal_default_instance()1662 static inline const ContextSwitch* internal_default_instance() {
1663 return reinterpret_cast<const ContextSwitch*>(
1664 &_ContextSwitch_default_instance_);
1665 }
1666 static constexpr int kIndexInFileMessages =
1667 7;
1668
swap(ContextSwitch & a,ContextSwitch & b)1669 friend void swap(ContextSwitch& a, ContextSwitch& b) {
1670 a.Swap(&b);
1671 }
Swap(ContextSwitch * other)1672 inline void Swap(ContextSwitch* other) {
1673 if (other == this) return;
1674 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1675 if (GetOwningArena() != nullptr &&
1676 GetOwningArena() == other->GetOwningArena()) {
1677 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1678 if (GetOwningArena() == other->GetOwningArena()) {
1679 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1680 InternalSwap(other);
1681 } else {
1682 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1683 }
1684 }
1685 void UnsafeArenaSwap(ContextSwitch* other) {
1686 if (other == this) return;
1687 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1688 InternalSwap(other);
1689 }
1690
1691 // implements Message ----------------------------------------------
1692
1693 ContextSwitch* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1694 return CreateMaybeMessage<ContextSwitch>(arena);
1695 }
1696 ContextSwitch* New() const {
1697 return New(nullptr);
1698 }
1699 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1700 void CopyFrom(const ContextSwitch& from);
1701 void MergeFrom(const ContextSwitch& from);
1702 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1703 bool IsInitialized() const final;
1704
1705 size_t ByteSizeLong() const final;
1706 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1707 ::uint8_t* _InternalSerialize(
1708 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1709 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1710
1711 private:
1712 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1713 void SharedDtor();
1714 void SetCachedSize(int size) const;
1715 void InternalSwap(ContextSwitch* other);
1716
1717 private:
1718 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1719 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1720 return "simpleperf_report_proto.ContextSwitch";
1721 }
1722 protected:
1723 explicit ContextSwitch(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1724 bool is_message_owned = false);
1725 public:
1726
1727 std::string GetTypeName() const final;
1728
1729 // nested types ----------------------------------------------------
1730
1731 // accessors -------------------------------------------------------
1732
1733 enum : int {
1734 kTimeFieldNumber = 2,
1735 kSwitchOnFieldNumber = 1,
1736 kThreadIdFieldNumber = 3,
1737 };
1738 // optional uint64 time = 2;
1739 bool has_time() const;
1740 private:
1741 bool _internal_has_time() const;
1742 public:
1743 void clear_time();
1744 ::uint64_t time() const;
1745 void set_time(::uint64_t value);
1746 private:
1747 ::uint64_t _internal_time() const;
1748 void _internal_set_time(::uint64_t value);
1749 public:
1750
1751 // optional bool switch_on = 1;
1752 bool has_switch_on() const;
1753 private:
1754 bool _internal_has_switch_on() const;
1755 public:
1756 void clear_switch_on();
1757 bool switch_on() const;
1758 void set_switch_on(bool value);
1759 private:
1760 bool _internal_switch_on() const;
1761 void _internal_set_switch_on(bool value);
1762 public:
1763
1764 // optional uint32 thread_id = 3;
1765 bool has_thread_id() const;
1766 private:
1767 bool _internal_has_thread_id() const;
1768 public:
1769 void clear_thread_id();
1770 ::uint32_t thread_id() const;
1771 void set_thread_id(::uint32_t value);
1772 private:
1773 ::uint32_t _internal_thread_id() const;
1774 void _internal_set_thread_id(::uint32_t value);
1775 public:
1776
1777 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.ContextSwitch)
1778 private:
1779 class _Internal;
1780
1781 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1782 typedef void InternalArenaConstructable_;
1783 typedef void DestructorSkippable_;
1784 struct Impl_ {
1785 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1786 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1787 ::uint64_t time_;
1788 bool switch_on_;
1789 ::uint32_t thread_id_;
1790 };
1791 union { Impl_ _impl_; };
1792 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
1793 };
1794 // -------------------------------------------------------------------
1795
1796 class Record final :
1797 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:simpleperf_report_proto.Record) */ {
1798 public:
Record()1799 inline Record() : Record(nullptr) {}
1800 ~Record() override;
1801 explicit PROTOBUF_CONSTEXPR Record(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1802
1803 Record(const Record& from);
Record(Record && from)1804 Record(Record&& from) noexcept
1805 : Record() {
1806 *this = ::std::move(from);
1807 }
1808
1809 inline Record& operator=(const Record& from) {
1810 if (this == &from) return *this;
1811 CopyFrom(from);
1812 return *this;
1813 }
1814 inline Record& operator=(Record&& from) noexcept {
1815 if (this == &from) return *this;
1816 if (GetOwningArena() == from.GetOwningArena()
1817 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1818 && GetOwningArena() != nullptr
1819 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1820 ) {
1821 InternalSwap(&from);
1822 } else {
1823 CopyFrom(from);
1824 }
1825 return *this;
1826 }
1827
unknown_fields()1828 inline const std::string& unknown_fields() const {
1829 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1830 }
mutable_unknown_fields()1831 inline std::string* mutable_unknown_fields() {
1832 return _internal_metadata_.mutable_unknown_fields<std::string>();
1833 }
1834
default_instance()1835 static const Record& default_instance() {
1836 return *internal_default_instance();
1837 }
1838 enum RecordDataCase {
1839 kSample = 1,
1840 kLost = 2,
1841 kFile = 3,
1842 kThread = 4,
1843 kMetaInfo = 5,
1844 kContextSwitch = 6,
1845 RECORD_DATA_NOT_SET = 0,
1846 };
1847
internal_default_instance()1848 static inline const Record* internal_default_instance() {
1849 return reinterpret_cast<const Record*>(
1850 &_Record_default_instance_);
1851 }
1852 static constexpr int kIndexInFileMessages =
1853 8;
1854
swap(Record & a,Record & b)1855 friend void swap(Record& a, Record& b) {
1856 a.Swap(&b);
1857 }
Swap(Record * other)1858 inline void Swap(Record* other) {
1859 if (other == this) return;
1860 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1861 if (GetOwningArena() != nullptr &&
1862 GetOwningArena() == other->GetOwningArena()) {
1863 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1864 if (GetOwningArena() == other->GetOwningArena()) {
1865 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1866 InternalSwap(other);
1867 } else {
1868 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1869 }
1870 }
1871 void UnsafeArenaSwap(Record* other) {
1872 if (other == this) return;
1873 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1874 InternalSwap(other);
1875 }
1876
1877 // implements Message ----------------------------------------------
1878
1879 Record* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1880 return CreateMaybeMessage<Record>(arena);
1881 }
1882 Record* New() const {
1883 return New(nullptr);
1884 }
1885 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1886 void CopyFrom(const Record& from);
1887 void MergeFrom(const Record& from);
1888 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1889 bool IsInitialized() const final;
1890
1891 size_t ByteSizeLong() const final;
1892 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1893 ::uint8_t* _InternalSerialize(
1894 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1895 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1896
1897 private:
1898 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1899 void SharedDtor();
1900 void SetCachedSize(int size) const;
1901 void InternalSwap(Record* other);
1902
1903 private:
1904 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1905 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1906 return "simpleperf_report_proto.Record";
1907 }
1908 protected:
1909 explicit Record(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1910 bool is_message_owned = false);
1911 public:
1912
1913 std::string GetTypeName() const final;
1914
1915 // nested types ----------------------------------------------------
1916
1917 // accessors -------------------------------------------------------
1918
1919 enum : int {
1920 kSampleFieldNumber = 1,
1921 kLostFieldNumber = 2,
1922 kFileFieldNumber = 3,
1923 kThreadFieldNumber = 4,
1924 kMetaInfoFieldNumber = 5,
1925 kContextSwitchFieldNumber = 6,
1926 };
1927 // .simpleperf_report_proto.Sample sample = 1;
1928 bool has_sample() const;
1929 private:
1930 bool _internal_has_sample() const;
1931 public:
1932 void clear_sample();
1933 const ::simpleperf_report_proto::Sample& sample() const;
1934 PROTOBUF_NODISCARD ::simpleperf_report_proto::Sample* release_sample();
1935 ::simpleperf_report_proto::Sample* mutable_sample();
1936 void set_allocated_sample(::simpleperf_report_proto::Sample* sample);
1937 private:
1938 const ::simpleperf_report_proto::Sample& _internal_sample() const;
1939 ::simpleperf_report_proto::Sample* _internal_mutable_sample();
1940 public:
1941 void unsafe_arena_set_allocated_sample(
1942 ::simpleperf_report_proto::Sample* sample);
1943 ::simpleperf_report_proto::Sample* unsafe_arena_release_sample();
1944
1945 // .simpleperf_report_proto.LostSituation lost = 2;
1946 bool has_lost() const;
1947 private:
1948 bool _internal_has_lost() const;
1949 public:
1950 void clear_lost();
1951 const ::simpleperf_report_proto::LostSituation& lost() const;
1952 PROTOBUF_NODISCARD ::simpleperf_report_proto::LostSituation* release_lost();
1953 ::simpleperf_report_proto::LostSituation* mutable_lost();
1954 void set_allocated_lost(::simpleperf_report_proto::LostSituation* lost);
1955 private:
1956 const ::simpleperf_report_proto::LostSituation& _internal_lost() const;
1957 ::simpleperf_report_proto::LostSituation* _internal_mutable_lost();
1958 public:
1959 void unsafe_arena_set_allocated_lost(
1960 ::simpleperf_report_proto::LostSituation* lost);
1961 ::simpleperf_report_proto::LostSituation* unsafe_arena_release_lost();
1962
1963 // .simpleperf_report_proto.File file = 3;
1964 bool has_file() const;
1965 private:
1966 bool _internal_has_file() const;
1967 public:
1968 void clear_file();
1969 const ::simpleperf_report_proto::File& file() const;
1970 PROTOBUF_NODISCARD ::simpleperf_report_proto::File* release_file();
1971 ::simpleperf_report_proto::File* mutable_file();
1972 void set_allocated_file(::simpleperf_report_proto::File* file);
1973 private:
1974 const ::simpleperf_report_proto::File& _internal_file() const;
1975 ::simpleperf_report_proto::File* _internal_mutable_file();
1976 public:
1977 void unsafe_arena_set_allocated_file(
1978 ::simpleperf_report_proto::File* file);
1979 ::simpleperf_report_proto::File* unsafe_arena_release_file();
1980
1981 // .simpleperf_report_proto.Thread thread = 4;
1982 bool has_thread() const;
1983 private:
1984 bool _internal_has_thread() const;
1985 public:
1986 void clear_thread();
1987 const ::simpleperf_report_proto::Thread& thread() const;
1988 PROTOBUF_NODISCARD ::simpleperf_report_proto::Thread* release_thread();
1989 ::simpleperf_report_proto::Thread* mutable_thread();
1990 void set_allocated_thread(::simpleperf_report_proto::Thread* thread);
1991 private:
1992 const ::simpleperf_report_proto::Thread& _internal_thread() const;
1993 ::simpleperf_report_proto::Thread* _internal_mutable_thread();
1994 public:
1995 void unsafe_arena_set_allocated_thread(
1996 ::simpleperf_report_proto::Thread* thread);
1997 ::simpleperf_report_proto::Thread* unsafe_arena_release_thread();
1998
1999 // .simpleperf_report_proto.MetaInfo meta_info = 5;
2000 bool has_meta_info() const;
2001 private:
2002 bool _internal_has_meta_info() const;
2003 public:
2004 void clear_meta_info();
2005 const ::simpleperf_report_proto::MetaInfo& meta_info() const;
2006 PROTOBUF_NODISCARD ::simpleperf_report_proto::MetaInfo* release_meta_info();
2007 ::simpleperf_report_proto::MetaInfo* mutable_meta_info();
2008 void set_allocated_meta_info(::simpleperf_report_proto::MetaInfo* meta_info);
2009 private:
2010 const ::simpleperf_report_proto::MetaInfo& _internal_meta_info() const;
2011 ::simpleperf_report_proto::MetaInfo* _internal_mutable_meta_info();
2012 public:
2013 void unsafe_arena_set_allocated_meta_info(
2014 ::simpleperf_report_proto::MetaInfo* meta_info);
2015 ::simpleperf_report_proto::MetaInfo* unsafe_arena_release_meta_info();
2016
2017 // .simpleperf_report_proto.ContextSwitch context_switch = 6;
2018 bool has_context_switch() const;
2019 private:
2020 bool _internal_has_context_switch() const;
2021 public:
2022 void clear_context_switch();
2023 const ::simpleperf_report_proto::ContextSwitch& context_switch() const;
2024 PROTOBUF_NODISCARD ::simpleperf_report_proto::ContextSwitch* release_context_switch();
2025 ::simpleperf_report_proto::ContextSwitch* mutable_context_switch();
2026 void set_allocated_context_switch(::simpleperf_report_proto::ContextSwitch* context_switch);
2027 private:
2028 const ::simpleperf_report_proto::ContextSwitch& _internal_context_switch() const;
2029 ::simpleperf_report_proto::ContextSwitch* _internal_mutable_context_switch();
2030 public:
2031 void unsafe_arena_set_allocated_context_switch(
2032 ::simpleperf_report_proto::ContextSwitch* context_switch);
2033 ::simpleperf_report_proto::ContextSwitch* unsafe_arena_release_context_switch();
2034
2035 void clear_record_data();
2036 RecordDataCase record_data_case() const;
2037 // @@protoc_insertion_point(class_scope:simpleperf_report_proto.Record)
2038 private:
2039 class _Internal;
2040 void set_has_sample();
2041 void set_has_lost();
2042 void set_has_file();
2043 void set_has_thread();
2044 void set_has_meta_info();
2045 void set_has_context_switch();
2046
2047 inline bool has_record_data() const;
2048 inline void clear_has_record_data();
2049
2050 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
2051 typedef void InternalArenaConstructable_;
2052 typedef void DestructorSkippable_;
2053 struct Impl_ {
2054 union RecordDataUnion {
2055 constexpr RecordDataUnion() : _constinit_{} {}
2056 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
2057 ::simpleperf_report_proto::Sample* sample_;
2058 ::simpleperf_report_proto::LostSituation* lost_;
2059 ::simpleperf_report_proto::File* file_;
2060 ::simpleperf_report_proto::Thread* thread_;
2061 ::simpleperf_report_proto::MetaInfo* meta_info_;
2062 ::simpleperf_report_proto::ContextSwitch* context_switch_;
2063 } record_data_;
2064 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
2065 ::uint32_t _oneof_case_[1];
2066
2067 };
2068 union { Impl_ _impl_; };
2069 friend struct ::TableStruct_system_2fextras_2fsimpleperf_2fcmd_5freport_5fsample_2eproto;
2070 };
2071 // ===================================================================
2072
2073
2074 // ===================================================================
2075
2076 #ifdef __GNUC__
2077 #pragma GCC diagnostic push
2078 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
2079 #endif // __GNUC__
2080 // Sample_CallChainEntry
2081
2082 // optional uint64 vaddr_in_file = 1;
_internal_has_vaddr_in_file()2083 inline bool Sample_CallChainEntry::_internal_has_vaddr_in_file() const {
2084 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2085 return value;
2086 }
has_vaddr_in_file()2087 inline bool Sample_CallChainEntry::has_vaddr_in_file() const {
2088 return _internal_has_vaddr_in_file();
2089 }
clear_vaddr_in_file()2090 inline void Sample_CallChainEntry::clear_vaddr_in_file() {
2091 _impl_.vaddr_in_file_ = ::uint64_t{0u};
2092 _impl_._has_bits_[0] &= ~0x00000001u;
2093 }
_internal_vaddr_in_file()2094 inline ::uint64_t Sample_CallChainEntry::_internal_vaddr_in_file() const {
2095 return _impl_.vaddr_in_file_;
2096 }
vaddr_in_file()2097 inline ::uint64_t Sample_CallChainEntry::vaddr_in_file() const {
2098 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.CallChainEntry.vaddr_in_file)
2099 return _internal_vaddr_in_file();
2100 }
_internal_set_vaddr_in_file(::uint64_t value)2101 inline void Sample_CallChainEntry::_internal_set_vaddr_in_file(::uint64_t value) {
2102 _impl_._has_bits_[0] |= 0x00000001u;
2103 _impl_.vaddr_in_file_ = value;
2104 }
set_vaddr_in_file(::uint64_t value)2105 inline void Sample_CallChainEntry::set_vaddr_in_file(::uint64_t value) {
2106 _internal_set_vaddr_in_file(value);
2107 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.CallChainEntry.vaddr_in_file)
2108 }
2109
2110 // optional uint32 file_id = 2;
_internal_has_file_id()2111 inline bool Sample_CallChainEntry::_internal_has_file_id() const {
2112 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2113 return value;
2114 }
has_file_id()2115 inline bool Sample_CallChainEntry::has_file_id() const {
2116 return _internal_has_file_id();
2117 }
clear_file_id()2118 inline void Sample_CallChainEntry::clear_file_id() {
2119 _impl_.file_id_ = 0u;
2120 _impl_._has_bits_[0] &= ~0x00000002u;
2121 }
_internal_file_id()2122 inline ::uint32_t Sample_CallChainEntry::_internal_file_id() const {
2123 return _impl_.file_id_;
2124 }
file_id()2125 inline ::uint32_t Sample_CallChainEntry::file_id() const {
2126 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.CallChainEntry.file_id)
2127 return _internal_file_id();
2128 }
_internal_set_file_id(::uint32_t value)2129 inline void Sample_CallChainEntry::_internal_set_file_id(::uint32_t value) {
2130 _impl_._has_bits_[0] |= 0x00000002u;
2131 _impl_.file_id_ = value;
2132 }
set_file_id(::uint32_t value)2133 inline void Sample_CallChainEntry::set_file_id(::uint32_t value) {
2134 _internal_set_file_id(value);
2135 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.CallChainEntry.file_id)
2136 }
2137
2138 // optional int32 symbol_id = 3;
_internal_has_symbol_id()2139 inline bool Sample_CallChainEntry::_internal_has_symbol_id() const {
2140 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2141 return value;
2142 }
has_symbol_id()2143 inline bool Sample_CallChainEntry::has_symbol_id() const {
2144 return _internal_has_symbol_id();
2145 }
clear_symbol_id()2146 inline void Sample_CallChainEntry::clear_symbol_id() {
2147 _impl_.symbol_id_ = 0;
2148 _impl_._has_bits_[0] &= ~0x00000004u;
2149 }
_internal_symbol_id()2150 inline ::int32_t Sample_CallChainEntry::_internal_symbol_id() const {
2151 return _impl_.symbol_id_;
2152 }
symbol_id()2153 inline ::int32_t Sample_CallChainEntry::symbol_id() const {
2154 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.CallChainEntry.symbol_id)
2155 return _internal_symbol_id();
2156 }
_internal_set_symbol_id(::int32_t value)2157 inline void Sample_CallChainEntry::_internal_set_symbol_id(::int32_t value) {
2158 _impl_._has_bits_[0] |= 0x00000004u;
2159 _impl_.symbol_id_ = value;
2160 }
set_symbol_id(::int32_t value)2161 inline void Sample_CallChainEntry::set_symbol_id(::int32_t value) {
2162 _internal_set_symbol_id(value);
2163 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.CallChainEntry.symbol_id)
2164 }
2165
2166 // optional .simpleperf_report_proto.Sample.CallChainEntry.ExecutionType execution_type = 4 [default = NATIVE_METHOD];
_internal_has_execution_type()2167 inline bool Sample_CallChainEntry::_internal_has_execution_type() const {
2168 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2169 return value;
2170 }
has_execution_type()2171 inline bool Sample_CallChainEntry::has_execution_type() const {
2172 return _internal_has_execution_type();
2173 }
clear_execution_type()2174 inline void Sample_CallChainEntry::clear_execution_type() {
2175 _impl_.execution_type_ = 0;
2176 _impl_._has_bits_[0] &= ~0x00000008u;
2177 }
_internal_execution_type()2178 inline ::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType Sample_CallChainEntry::_internal_execution_type() const {
2179 return static_cast< ::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType >(_impl_.execution_type_);
2180 }
execution_type()2181 inline ::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType Sample_CallChainEntry::execution_type() const {
2182 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.CallChainEntry.execution_type)
2183 return _internal_execution_type();
2184 }
_internal_set_execution_type(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType value)2185 inline void Sample_CallChainEntry::_internal_set_execution_type(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType value) {
2186 assert(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType_IsValid(value));
2187 _impl_._has_bits_[0] |= 0x00000008u;
2188 _impl_.execution_type_ = value;
2189 }
set_execution_type(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType value)2190 inline void Sample_CallChainEntry::set_execution_type(::simpleperf_report_proto::Sample_CallChainEntry_ExecutionType value) {
2191 _internal_set_execution_type(value);
2192 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.CallChainEntry.execution_type)
2193 }
2194
2195 // -------------------------------------------------------------------
2196
2197 // Sample_UnwindingResult
2198
2199 // optional uint32 raw_error_code = 1;
_internal_has_raw_error_code()2200 inline bool Sample_UnwindingResult::_internal_has_raw_error_code() const {
2201 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2202 return value;
2203 }
has_raw_error_code()2204 inline bool Sample_UnwindingResult::has_raw_error_code() const {
2205 return _internal_has_raw_error_code();
2206 }
clear_raw_error_code()2207 inline void Sample_UnwindingResult::clear_raw_error_code() {
2208 _impl_.raw_error_code_ = 0u;
2209 _impl_._has_bits_[0] &= ~0x00000002u;
2210 }
_internal_raw_error_code()2211 inline ::uint32_t Sample_UnwindingResult::_internal_raw_error_code() const {
2212 return _impl_.raw_error_code_;
2213 }
raw_error_code()2214 inline ::uint32_t Sample_UnwindingResult::raw_error_code() const {
2215 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.UnwindingResult.raw_error_code)
2216 return _internal_raw_error_code();
2217 }
_internal_set_raw_error_code(::uint32_t value)2218 inline void Sample_UnwindingResult::_internal_set_raw_error_code(::uint32_t value) {
2219 _impl_._has_bits_[0] |= 0x00000002u;
2220 _impl_.raw_error_code_ = value;
2221 }
set_raw_error_code(::uint32_t value)2222 inline void Sample_UnwindingResult::set_raw_error_code(::uint32_t value) {
2223 _internal_set_raw_error_code(value);
2224 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.UnwindingResult.raw_error_code)
2225 }
2226
2227 // optional uint64 error_addr = 2;
_internal_has_error_addr()2228 inline bool Sample_UnwindingResult::_internal_has_error_addr() const {
2229 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2230 return value;
2231 }
has_error_addr()2232 inline bool Sample_UnwindingResult::has_error_addr() const {
2233 return _internal_has_error_addr();
2234 }
clear_error_addr()2235 inline void Sample_UnwindingResult::clear_error_addr() {
2236 _impl_.error_addr_ = ::uint64_t{0u};
2237 _impl_._has_bits_[0] &= ~0x00000001u;
2238 }
_internal_error_addr()2239 inline ::uint64_t Sample_UnwindingResult::_internal_error_addr() const {
2240 return _impl_.error_addr_;
2241 }
error_addr()2242 inline ::uint64_t Sample_UnwindingResult::error_addr() const {
2243 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.UnwindingResult.error_addr)
2244 return _internal_error_addr();
2245 }
_internal_set_error_addr(::uint64_t value)2246 inline void Sample_UnwindingResult::_internal_set_error_addr(::uint64_t value) {
2247 _impl_._has_bits_[0] |= 0x00000001u;
2248 _impl_.error_addr_ = value;
2249 }
set_error_addr(::uint64_t value)2250 inline void Sample_UnwindingResult::set_error_addr(::uint64_t value) {
2251 _internal_set_error_addr(value);
2252 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.UnwindingResult.error_addr)
2253 }
2254
2255 // optional .simpleperf_report_proto.Sample.UnwindingResult.ErrorCode error_code = 3;
_internal_has_error_code()2256 inline bool Sample_UnwindingResult::_internal_has_error_code() const {
2257 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2258 return value;
2259 }
has_error_code()2260 inline bool Sample_UnwindingResult::has_error_code() const {
2261 return _internal_has_error_code();
2262 }
clear_error_code()2263 inline void Sample_UnwindingResult::clear_error_code() {
2264 _impl_.error_code_ = 0;
2265 _impl_._has_bits_[0] &= ~0x00000004u;
2266 }
_internal_error_code()2267 inline ::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode Sample_UnwindingResult::_internal_error_code() const {
2268 return static_cast< ::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode >(_impl_.error_code_);
2269 }
error_code()2270 inline ::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode Sample_UnwindingResult::error_code() const {
2271 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.UnwindingResult.error_code)
2272 return _internal_error_code();
2273 }
_internal_set_error_code(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode value)2274 inline void Sample_UnwindingResult::_internal_set_error_code(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode value) {
2275 assert(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode_IsValid(value));
2276 _impl_._has_bits_[0] |= 0x00000004u;
2277 _impl_.error_code_ = value;
2278 }
set_error_code(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode value)2279 inline void Sample_UnwindingResult::set_error_code(::simpleperf_report_proto::Sample_UnwindingResult_ErrorCode value) {
2280 _internal_set_error_code(value);
2281 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.UnwindingResult.error_code)
2282 }
2283
2284 // -------------------------------------------------------------------
2285
2286 // Sample
2287
2288 // optional uint64 time = 1;
_internal_has_time()2289 inline bool Sample::_internal_has_time() const {
2290 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2291 return value;
2292 }
has_time()2293 inline bool Sample::has_time() const {
2294 return _internal_has_time();
2295 }
clear_time()2296 inline void Sample::clear_time() {
2297 _impl_.time_ = ::uint64_t{0u};
2298 _impl_._has_bits_[0] &= ~0x00000002u;
2299 }
_internal_time()2300 inline ::uint64_t Sample::_internal_time() const {
2301 return _impl_.time_;
2302 }
time()2303 inline ::uint64_t Sample::time() const {
2304 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.time)
2305 return _internal_time();
2306 }
_internal_set_time(::uint64_t value)2307 inline void Sample::_internal_set_time(::uint64_t value) {
2308 _impl_._has_bits_[0] |= 0x00000002u;
2309 _impl_.time_ = value;
2310 }
set_time(::uint64_t value)2311 inline void Sample::set_time(::uint64_t value) {
2312 _internal_set_time(value);
2313 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.time)
2314 }
2315
2316 // optional int32 thread_id = 2;
_internal_has_thread_id()2317 inline bool Sample::_internal_has_thread_id() const {
2318 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2319 return value;
2320 }
has_thread_id()2321 inline bool Sample::has_thread_id() const {
2322 return _internal_has_thread_id();
2323 }
clear_thread_id()2324 inline void Sample::clear_thread_id() {
2325 _impl_.thread_id_ = 0;
2326 _impl_._has_bits_[0] &= ~0x00000004u;
2327 }
_internal_thread_id()2328 inline ::int32_t Sample::_internal_thread_id() const {
2329 return _impl_.thread_id_;
2330 }
thread_id()2331 inline ::int32_t Sample::thread_id() const {
2332 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.thread_id)
2333 return _internal_thread_id();
2334 }
_internal_set_thread_id(::int32_t value)2335 inline void Sample::_internal_set_thread_id(::int32_t value) {
2336 _impl_._has_bits_[0] |= 0x00000004u;
2337 _impl_.thread_id_ = value;
2338 }
set_thread_id(::int32_t value)2339 inline void Sample::set_thread_id(::int32_t value) {
2340 _internal_set_thread_id(value);
2341 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.thread_id)
2342 }
2343
2344 // repeated .simpleperf_report_proto.Sample.CallChainEntry callchain = 3;
_internal_callchain_size()2345 inline int Sample::_internal_callchain_size() const {
2346 return _impl_.callchain_.size();
2347 }
callchain_size()2348 inline int Sample::callchain_size() const {
2349 return _internal_callchain_size();
2350 }
clear_callchain()2351 inline void Sample::clear_callchain() {
2352 _impl_.callchain_.Clear();
2353 }
mutable_callchain(int index)2354 inline ::simpleperf_report_proto::Sample_CallChainEntry* Sample::mutable_callchain(int index) {
2355 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.Sample.callchain)
2356 return _impl_.callchain_.Mutable(index);
2357 }
2358 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::simpleperf_report_proto::Sample_CallChainEntry >*
mutable_callchain()2359 Sample::mutable_callchain() {
2360 // @@protoc_insertion_point(field_mutable_list:simpleperf_report_proto.Sample.callchain)
2361 return &_impl_.callchain_;
2362 }
_internal_callchain(int index)2363 inline const ::simpleperf_report_proto::Sample_CallChainEntry& Sample::_internal_callchain(int index) const {
2364 return _impl_.callchain_.Get(index);
2365 }
callchain(int index)2366 inline const ::simpleperf_report_proto::Sample_CallChainEntry& Sample::callchain(int index) const {
2367 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.callchain)
2368 return _internal_callchain(index);
2369 }
_internal_add_callchain()2370 inline ::simpleperf_report_proto::Sample_CallChainEntry* Sample::_internal_add_callchain() {
2371 return _impl_.callchain_.Add();
2372 }
add_callchain()2373 inline ::simpleperf_report_proto::Sample_CallChainEntry* Sample::add_callchain() {
2374 ::simpleperf_report_proto::Sample_CallChainEntry* _add = _internal_add_callchain();
2375 // @@protoc_insertion_point(field_add:simpleperf_report_proto.Sample.callchain)
2376 return _add;
2377 }
2378 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::simpleperf_report_proto::Sample_CallChainEntry >&
callchain()2379 Sample::callchain() const {
2380 // @@protoc_insertion_point(field_list:simpleperf_report_proto.Sample.callchain)
2381 return _impl_.callchain_;
2382 }
2383
2384 // optional uint64 event_count = 4;
_internal_has_event_count()2385 inline bool Sample::_internal_has_event_count() const {
2386 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2387 return value;
2388 }
has_event_count()2389 inline bool Sample::has_event_count() const {
2390 return _internal_has_event_count();
2391 }
clear_event_count()2392 inline void Sample::clear_event_count() {
2393 _impl_.event_count_ = ::uint64_t{0u};
2394 _impl_._has_bits_[0] &= ~0x00000010u;
2395 }
_internal_event_count()2396 inline ::uint64_t Sample::_internal_event_count() const {
2397 return _impl_.event_count_;
2398 }
event_count()2399 inline ::uint64_t Sample::event_count() const {
2400 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.event_count)
2401 return _internal_event_count();
2402 }
_internal_set_event_count(::uint64_t value)2403 inline void Sample::_internal_set_event_count(::uint64_t value) {
2404 _impl_._has_bits_[0] |= 0x00000010u;
2405 _impl_.event_count_ = value;
2406 }
set_event_count(::uint64_t value)2407 inline void Sample::set_event_count(::uint64_t value) {
2408 _internal_set_event_count(value);
2409 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.event_count)
2410 }
2411
2412 // optional uint32 event_type_id = 5;
_internal_has_event_type_id()2413 inline bool Sample::_internal_has_event_type_id() const {
2414 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2415 return value;
2416 }
has_event_type_id()2417 inline bool Sample::has_event_type_id() const {
2418 return _internal_has_event_type_id();
2419 }
clear_event_type_id()2420 inline void Sample::clear_event_type_id() {
2421 _impl_.event_type_id_ = 0u;
2422 _impl_._has_bits_[0] &= ~0x00000008u;
2423 }
_internal_event_type_id()2424 inline ::uint32_t Sample::_internal_event_type_id() const {
2425 return _impl_.event_type_id_;
2426 }
event_type_id()2427 inline ::uint32_t Sample::event_type_id() const {
2428 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.event_type_id)
2429 return _internal_event_type_id();
2430 }
_internal_set_event_type_id(::uint32_t value)2431 inline void Sample::_internal_set_event_type_id(::uint32_t value) {
2432 _impl_._has_bits_[0] |= 0x00000008u;
2433 _impl_.event_type_id_ = value;
2434 }
set_event_type_id(::uint32_t value)2435 inline void Sample::set_event_type_id(::uint32_t value) {
2436 _internal_set_event_type_id(value);
2437 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Sample.event_type_id)
2438 }
2439
2440 // optional .simpleperf_report_proto.Sample.UnwindingResult unwinding_result = 6;
_internal_has_unwinding_result()2441 inline bool Sample::_internal_has_unwinding_result() const {
2442 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2443 PROTOBUF_ASSUME(!value || _impl_.unwinding_result_ != nullptr);
2444 return value;
2445 }
has_unwinding_result()2446 inline bool Sample::has_unwinding_result() const {
2447 return _internal_has_unwinding_result();
2448 }
clear_unwinding_result()2449 inline void Sample::clear_unwinding_result() {
2450 if (_impl_.unwinding_result_ != nullptr) _impl_.unwinding_result_->Clear();
2451 _impl_._has_bits_[0] &= ~0x00000001u;
2452 }
_internal_unwinding_result()2453 inline const ::simpleperf_report_proto::Sample_UnwindingResult& Sample::_internal_unwinding_result() const {
2454 const ::simpleperf_report_proto::Sample_UnwindingResult* p = _impl_.unwinding_result_;
2455 return p != nullptr ? *p : reinterpret_cast<const ::simpleperf_report_proto::Sample_UnwindingResult&>(
2456 ::simpleperf_report_proto::_Sample_UnwindingResult_default_instance_);
2457 }
unwinding_result()2458 inline const ::simpleperf_report_proto::Sample_UnwindingResult& Sample::unwinding_result() const {
2459 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Sample.unwinding_result)
2460 return _internal_unwinding_result();
2461 }
unsafe_arena_set_allocated_unwinding_result(::simpleperf_report_proto::Sample_UnwindingResult * unwinding_result)2462 inline void Sample::unsafe_arena_set_allocated_unwinding_result(
2463 ::simpleperf_report_proto::Sample_UnwindingResult* unwinding_result) {
2464 if (GetArenaForAllocation() == nullptr) {
2465 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.unwinding_result_);
2466 }
2467 _impl_.unwinding_result_ = unwinding_result;
2468 if (unwinding_result) {
2469 _impl_._has_bits_[0] |= 0x00000001u;
2470 } else {
2471 _impl_._has_bits_[0] &= ~0x00000001u;
2472 }
2473 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:simpleperf_report_proto.Sample.unwinding_result)
2474 }
release_unwinding_result()2475 inline ::simpleperf_report_proto::Sample_UnwindingResult* Sample::release_unwinding_result() {
2476 _impl_._has_bits_[0] &= ~0x00000001u;
2477 ::simpleperf_report_proto::Sample_UnwindingResult* temp = _impl_.unwinding_result_;
2478 _impl_.unwinding_result_ = nullptr;
2479 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2480 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2481 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2482 if (GetArenaForAllocation() == nullptr) { delete old; }
2483 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2484 if (GetArenaForAllocation() != nullptr) {
2485 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2486 }
2487 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2488 return temp;
2489 }
unsafe_arena_release_unwinding_result()2490 inline ::simpleperf_report_proto::Sample_UnwindingResult* Sample::unsafe_arena_release_unwinding_result() {
2491 // @@protoc_insertion_point(field_release:simpleperf_report_proto.Sample.unwinding_result)
2492 _impl_._has_bits_[0] &= ~0x00000001u;
2493 ::simpleperf_report_proto::Sample_UnwindingResult* temp = _impl_.unwinding_result_;
2494 _impl_.unwinding_result_ = nullptr;
2495 return temp;
2496 }
_internal_mutable_unwinding_result()2497 inline ::simpleperf_report_proto::Sample_UnwindingResult* Sample::_internal_mutable_unwinding_result() {
2498 _impl_._has_bits_[0] |= 0x00000001u;
2499 if (_impl_.unwinding_result_ == nullptr) {
2500 auto* p = CreateMaybeMessage<::simpleperf_report_proto::Sample_UnwindingResult>(GetArenaForAllocation());
2501 _impl_.unwinding_result_ = p;
2502 }
2503 return _impl_.unwinding_result_;
2504 }
mutable_unwinding_result()2505 inline ::simpleperf_report_proto::Sample_UnwindingResult* Sample::mutable_unwinding_result() {
2506 ::simpleperf_report_proto::Sample_UnwindingResult* _msg = _internal_mutable_unwinding_result();
2507 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.Sample.unwinding_result)
2508 return _msg;
2509 }
set_allocated_unwinding_result(::simpleperf_report_proto::Sample_UnwindingResult * unwinding_result)2510 inline void Sample::set_allocated_unwinding_result(::simpleperf_report_proto::Sample_UnwindingResult* unwinding_result) {
2511 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2512 if (message_arena == nullptr) {
2513 delete _impl_.unwinding_result_;
2514 }
2515 if (unwinding_result) {
2516 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2517 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(unwinding_result);
2518 if (message_arena != submessage_arena) {
2519 unwinding_result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2520 message_arena, unwinding_result, submessage_arena);
2521 }
2522 _impl_._has_bits_[0] |= 0x00000001u;
2523 } else {
2524 _impl_._has_bits_[0] &= ~0x00000001u;
2525 }
2526 _impl_.unwinding_result_ = unwinding_result;
2527 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.Sample.unwinding_result)
2528 }
2529
2530 // -------------------------------------------------------------------
2531
2532 // LostSituation
2533
2534 // optional uint64 sample_count = 1;
_internal_has_sample_count()2535 inline bool LostSituation::_internal_has_sample_count() const {
2536 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2537 return value;
2538 }
has_sample_count()2539 inline bool LostSituation::has_sample_count() const {
2540 return _internal_has_sample_count();
2541 }
clear_sample_count()2542 inline void LostSituation::clear_sample_count() {
2543 _impl_.sample_count_ = ::uint64_t{0u};
2544 _impl_._has_bits_[0] &= ~0x00000001u;
2545 }
_internal_sample_count()2546 inline ::uint64_t LostSituation::_internal_sample_count() const {
2547 return _impl_.sample_count_;
2548 }
sample_count()2549 inline ::uint64_t LostSituation::sample_count() const {
2550 // @@protoc_insertion_point(field_get:simpleperf_report_proto.LostSituation.sample_count)
2551 return _internal_sample_count();
2552 }
_internal_set_sample_count(::uint64_t value)2553 inline void LostSituation::_internal_set_sample_count(::uint64_t value) {
2554 _impl_._has_bits_[0] |= 0x00000001u;
2555 _impl_.sample_count_ = value;
2556 }
set_sample_count(::uint64_t value)2557 inline void LostSituation::set_sample_count(::uint64_t value) {
2558 _internal_set_sample_count(value);
2559 // @@protoc_insertion_point(field_set:simpleperf_report_proto.LostSituation.sample_count)
2560 }
2561
2562 // optional uint64 lost_count = 2;
_internal_has_lost_count()2563 inline bool LostSituation::_internal_has_lost_count() const {
2564 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2565 return value;
2566 }
has_lost_count()2567 inline bool LostSituation::has_lost_count() const {
2568 return _internal_has_lost_count();
2569 }
clear_lost_count()2570 inline void LostSituation::clear_lost_count() {
2571 _impl_.lost_count_ = ::uint64_t{0u};
2572 _impl_._has_bits_[0] &= ~0x00000002u;
2573 }
_internal_lost_count()2574 inline ::uint64_t LostSituation::_internal_lost_count() const {
2575 return _impl_.lost_count_;
2576 }
lost_count()2577 inline ::uint64_t LostSituation::lost_count() const {
2578 // @@protoc_insertion_point(field_get:simpleperf_report_proto.LostSituation.lost_count)
2579 return _internal_lost_count();
2580 }
_internal_set_lost_count(::uint64_t value)2581 inline void LostSituation::_internal_set_lost_count(::uint64_t value) {
2582 _impl_._has_bits_[0] |= 0x00000002u;
2583 _impl_.lost_count_ = value;
2584 }
set_lost_count(::uint64_t value)2585 inline void LostSituation::set_lost_count(::uint64_t value) {
2586 _internal_set_lost_count(value);
2587 // @@protoc_insertion_point(field_set:simpleperf_report_proto.LostSituation.lost_count)
2588 }
2589
2590 // -------------------------------------------------------------------
2591
2592 // File
2593
2594 // optional uint32 id = 1;
_internal_has_id()2595 inline bool File::_internal_has_id() const {
2596 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2597 return value;
2598 }
has_id()2599 inline bool File::has_id() const {
2600 return _internal_has_id();
2601 }
clear_id()2602 inline void File::clear_id() {
2603 _impl_.id_ = 0u;
2604 _impl_._has_bits_[0] &= ~0x00000002u;
2605 }
_internal_id()2606 inline ::uint32_t File::_internal_id() const {
2607 return _impl_.id_;
2608 }
id()2609 inline ::uint32_t File::id() const {
2610 // @@protoc_insertion_point(field_get:simpleperf_report_proto.File.id)
2611 return _internal_id();
2612 }
_internal_set_id(::uint32_t value)2613 inline void File::_internal_set_id(::uint32_t value) {
2614 _impl_._has_bits_[0] |= 0x00000002u;
2615 _impl_.id_ = value;
2616 }
set_id(::uint32_t value)2617 inline void File::set_id(::uint32_t value) {
2618 _internal_set_id(value);
2619 // @@protoc_insertion_point(field_set:simpleperf_report_proto.File.id)
2620 }
2621
2622 // optional string path = 2;
_internal_has_path()2623 inline bool File::_internal_has_path() const {
2624 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2625 return value;
2626 }
has_path()2627 inline bool File::has_path() const {
2628 return _internal_has_path();
2629 }
clear_path()2630 inline void File::clear_path() {
2631 _impl_.path_.ClearToEmpty();
2632 _impl_._has_bits_[0] &= ~0x00000001u;
2633 }
path()2634 inline const std::string& File::path() const {
2635 // @@protoc_insertion_point(field_get:simpleperf_report_proto.File.path)
2636 return _internal_path();
2637 }
2638 template <typename ArgT0, typename... ArgT>
2639 inline PROTOBUF_ALWAYS_INLINE
set_path(ArgT0 && arg0,ArgT...args)2640 void File::set_path(ArgT0&& arg0, ArgT... args) {
2641 _impl_._has_bits_[0] |= 0x00000001u;
2642 _impl_.path_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2643 // @@protoc_insertion_point(field_set:simpleperf_report_proto.File.path)
2644 }
mutable_path()2645 inline std::string* File::mutable_path() {
2646 std::string* _s = _internal_mutable_path();
2647 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.File.path)
2648 return _s;
2649 }
_internal_path()2650 inline const std::string& File::_internal_path() const {
2651 return _impl_.path_.Get();
2652 }
_internal_set_path(const std::string & value)2653 inline void File::_internal_set_path(const std::string& value) {
2654 _impl_._has_bits_[0] |= 0x00000001u;
2655 _impl_.path_.Set(value, GetArenaForAllocation());
2656 }
_internal_mutable_path()2657 inline std::string* File::_internal_mutable_path() {
2658 _impl_._has_bits_[0] |= 0x00000001u;
2659 return _impl_.path_.Mutable(GetArenaForAllocation());
2660 }
release_path()2661 inline std::string* File::release_path() {
2662 // @@protoc_insertion_point(field_release:simpleperf_report_proto.File.path)
2663 if (!_internal_has_path()) {
2664 return nullptr;
2665 }
2666 _impl_._has_bits_[0] &= ~0x00000001u;
2667 auto* p = _impl_.path_.Release();
2668 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2669 if (_impl_.path_.IsDefault()) {
2670 _impl_.path_.Set("", GetArenaForAllocation());
2671 }
2672 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2673 return p;
2674 }
set_allocated_path(std::string * path)2675 inline void File::set_allocated_path(std::string* path) {
2676 if (path != nullptr) {
2677 _impl_._has_bits_[0] |= 0x00000001u;
2678 } else {
2679 _impl_._has_bits_[0] &= ~0x00000001u;
2680 }
2681 _impl_.path_.SetAllocated(path, GetArenaForAllocation());
2682 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2683 if (_impl_.path_.IsDefault()) {
2684 _impl_.path_.Set("", GetArenaForAllocation());
2685 }
2686 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2687 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.File.path)
2688 }
2689
2690 // repeated string symbol = 3;
_internal_symbol_size()2691 inline int File::_internal_symbol_size() const {
2692 return _impl_.symbol_.size();
2693 }
symbol_size()2694 inline int File::symbol_size() const {
2695 return _internal_symbol_size();
2696 }
clear_symbol()2697 inline void File::clear_symbol() {
2698 _impl_.symbol_.Clear();
2699 }
add_symbol()2700 inline std::string* File::add_symbol() {
2701 std::string* _s = _internal_add_symbol();
2702 // @@protoc_insertion_point(field_add_mutable:simpleperf_report_proto.File.symbol)
2703 return _s;
2704 }
_internal_symbol(int index)2705 inline const std::string& File::_internal_symbol(int index) const {
2706 return _impl_.symbol_.Get(index);
2707 }
symbol(int index)2708 inline const std::string& File::symbol(int index) const {
2709 // @@protoc_insertion_point(field_get:simpleperf_report_proto.File.symbol)
2710 return _internal_symbol(index);
2711 }
mutable_symbol(int index)2712 inline std::string* File::mutable_symbol(int index) {
2713 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.File.symbol)
2714 return _impl_.symbol_.Mutable(index);
2715 }
set_symbol(int index,const std::string & value)2716 inline void File::set_symbol(int index, const std::string& value) {
2717 _impl_.symbol_.Mutable(index)->assign(value);
2718 // @@protoc_insertion_point(field_set:simpleperf_report_proto.File.symbol)
2719 }
set_symbol(int index,std::string && value)2720 inline void File::set_symbol(int index, std::string&& value) {
2721 _impl_.symbol_.Mutable(index)->assign(std::move(value));
2722 // @@protoc_insertion_point(field_set:simpleperf_report_proto.File.symbol)
2723 }
set_symbol(int index,const char * value)2724 inline void File::set_symbol(int index, const char* value) {
2725 GOOGLE_DCHECK(value != nullptr);
2726 _impl_.symbol_.Mutable(index)->assign(value);
2727 // @@protoc_insertion_point(field_set_char:simpleperf_report_proto.File.symbol)
2728 }
set_symbol(int index,const char * value,size_t size)2729 inline void File::set_symbol(int index, const char* value, size_t size) {
2730 _impl_.symbol_.Mutable(index)->assign(
2731 reinterpret_cast<const char*>(value), size);
2732 // @@protoc_insertion_point(field_set_pointer:simpleperf_report_proto.File.symbol)
2733 }
_internal_add_symbol()2734 inline std::string* File::_internal_add_symbol() {
2735 return _impl_.symbol_.Add();
2736 }
add_symbol(const std::string & value)2737 inline void File::add_symbol(const std::string& value) {
2738 _impl_.symbol_.Add()->assign(value);
2739 // @@protoc_insertion_point(field_add:simpleperf_report_proto.File.symbol)
2740 }
add_symbol(std::string && value)2741 inline void File::add_symbol(std::string&& value) {
2742 _impl_.symbol_.Add(std::move(value));
2743 // @@protoc_insertion_point(field_add:simpleperf_report_proto.File.symbol)
2744 }
add_symbol(const char * value)2745 inline void File::add_symbol(const char* value) {
2746 GOOGLE_DCHECK(value != nullptr);
2747 _impl_.symbol_.Add()->assign(value);
2748 // @@protoc_insertion_point(field_add_char:simpleperf_report_proto.File.symbol)
2749 }
add_symbol(const char * value,size_t size)2750 inline void File::add_symbol(const char* value, size_t size) {
2751 _impl_.symbol_.Add()->assign(reinterpret_cast<const char*>(value), size);
2752 // @@protoc_insertion_point(field_add_pointer:simpleperf_report_proto.File.symbol)
2753 }
2754 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
symbol()2755 File::symbol() const {
2756 // @@protoc_insertion_point(field_list:simpleperf_report_proto.File.symbol)
2757 return _impl_.symbol_;
2758 }
2759 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_symbol()2760 File::mutable_symbol() {
2761 // @@protoc_insertion_point(field_mutable_list:simpleperf_report_proto.File.symbol)
2762 return &_impl_.symbol_;
2763 }
2764
2765 // repeated string mangled_symbol = 4;
_internal_mangled_symbol_size()2766 inline int File::_internal_mangled_symbol_size() const {
2767 return _impl_.mangled_symbol_.size();
2768 }
mangled_symbol_size()2769 inline int File::mangled_symbol_size() const {
2770 return _internal_mangled_symbol_size();
2771 }
clear_mangled_symbol()2772 inline void File::clear_mangled_symbol() {
2773 _impl_.mangled_symbol_.Clear();
2774 }
add_mangled_symbol()2775 inline std::string* File::add_mangled_symbol() {
2776 std::string* _s = _internal_add_mangled_symbol();
2777 // @@protoc_insertion_point(field_add_mutable:simpleperf_report_proto.File.mangled_symbol)
2778 return _s;
2779 }
_internal_mangled_symbol(int index)2780 inline const std::string& File::_internal_mangled_symbol(int index) const {
2781 return _impl_.mangled_symbol_.Get(index);
2782 }
mangled_symbol(int index)2783 inline const std::string& File::mangled_symbol(int index) const {
2784 // @@protoc_insertion_point(field_get:simpleperf_report_proto.File.mangled_symbol)
2785 return _internal_mangled_symbol(index);
2786 }
mutable_mangled_symbol(int index)2787 inline std::string* File::mutable_mangled_symbol(int index) {
2788 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.File.mangled_symbol)
2789 return _impl_.mangled_symbol_.Mutable(index);
2790 }
set_mangled_symbol(int index,const std::string & value)2791 inline void File::set_mangled_symbol(int index, const std::string& value) {
2792 _impl_.mangled_symbol_.Mutable(index)->assign(value);
2793 // @@protoc_insertion_point(field_set:simpleperf_report_proto.File.mangled_symbol)
2794 }
set_mangled_symbol(int index,std::string && value)2795 inline void File::set_mangled_symbol(int index, std::string&& value) {
2796 _impl_.mangled_symbol_.Mutable(index)->assign(std::move(value));
2797 // @@protoc_insertion_point(field_set:simpleperf_report_proto.File.mangled_symbol)
2798 }
set_mangled_symbol(int index,const char * value)2799 inline void File::set_mangled_symbol(int index, const char* value) {
2800 GOOGLE_DCHECK(value != nullptr);
2801 _impl_.mangled_symbol_.Mutable(index)->assign(value);
2802 // @@protoc_insertion_point(field_set_char:simpleperf_report_proto.File.mangled_symbol)
2803 }
set_mangled_symbol(int index,const char * value,size_t size)2804 inline void File::set_mangled_symbol(int index, const char* value, size_t size) {
2805 _impl_.mangled_symbol_.Mutable(index)->assign(
2806 reinterpret_cast<const char*>(value), size);
2807 // @@protoc_insertion_point(field_set_pointer:simpleperf_report_proto.File.mangled_symbol)
2808 }
_internal_add_mangled_symbol()2809 inline std::string* File::_internal_add_mangled_symbol() {
2810 return _impl_.mangled_symbol_.Add();
2811 }
add_mangled_symbol(const std::string & value)2812 inline void File::add_mangled_symbol(const std::string& value) {
2813 _impl_.mangled_symbol_.Add()->assign(value);
2814 // @@protoc_insertion_point(field_add:simpleperf_report_proto.File.mangled_symbol)
2815 }
add_mangled_symbol(std::string && value)2816 inline void File::add_mangled_symbol(std::string&& value) {
2817 _impl_.mangled_symbol_.Add(std::move(value));
2818 // @@protoc_insertion_point(field_add:simpleperf_report_proto.File.mangled_symbol)
2819 }
add_mangled_symbol(const char * value)2820 inline void File::add_mangled_symbol(const char* value) {
2821 GOOGLE_DCHECK(value != nullptr);
2822 _impl_.mangled_symbol_.Add()->assign(value);
2823 // @@protoc_insertion_point(field_add_char:simpleperf_report_proto.File.mangled_symbol)
2824 }
add_mangled_symbol(const char * value,size_t size)2825 inline void File::add_mangled_symbol(const char* value, size_t size) {
2826 _impl_.mangled_symbol_.Add()->assign(reinterpret_cast<const char*>(value), size);
2827 // @@protoc_insertion_point(field_add_pointer:simpleperf_report_proto.File.mangled_symbol)
2828 }
2829 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
mangled_symbol()2830 File::mangled_symbol() const {
2831 // @@protoc_insertion_point(field_list:simpleperf_report_proto.File.mangled_symbol)
2832 return _impl_.mangled_symbol_;
2833 }
2834 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_mangled_symbol()2835 File::mutable_mangled_symbol() {
2836 // @@protoc_insertion_point(field_mutable_list:simpleperf_report_proto.File.mangled_symbol)
2837 return &_impl_.mangled_symbol_;
2838 }
2839
2840 // -------------------------------------------------------------------
2841
2842 // Thread
2843
2844 // optional uint32 thread_id = 1;
_internal_has_thread_id()2845 inline bool Thread::_internal_has_thread_id() const {
2846 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2847 return value;
2848 }
has_thread_id()2849 inline bool Thread::has_thread_id() const {
2850 return _internal_has_thread_id();
2851 }
clear_thread_id()2852 inline void Thread::clear_thread_id() {
2853 _impl_.thread_id_ = 0u;
2854 _impl_._has_bits_[0] &= ~0x00000002u;
2855 }
_internal_thread_id()2856 inline ::uint32_t Thread::_internal_thread_id() const {
2857 return _impl_.thread_id_;
2858 }
thread_id()2859 inline ::uint32_t Thread::thread_id() const {
2860 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Thread.thread_id)
2861 return _internal_thread_id();
2862 }
_internal_set_thread_id(::uint32_t value)2863 inline void Thread::_internal_set_thread_id(::uint32_t value) {
2864 _impl_._has_bits_[0] |= 0x00000002u;
2865 _impl_.thread_id_ = value;
2866 }
set_thread_id(::uint32_t value)2867 inline void Thread::set_thread_id(::uint32_t value) {
2868 _internal_set_thread_id(value);
2869 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Thread.thread_id)
2870 }
2871
2872 // optional uint32 process_id = 2;
_internal_has_process_id()2873 inline bool Thread::_internal_has_process_id() const {
2874 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2875 return value;
2876 }
has_process_id()2877 inline bool Thread::has_process_id() const {
2878 return _internal_has_process_id();
2879 }
clear_process_id()2880 inline void Thread::clear_process_id() {
2881 _impl_.process_id_ = 0u;
2882 _impl_._has_bits_[0] &= ~0x00000004u;
2883 }
_internal_process_id()2884 inline ::uint32_t Thread::_internal_process_id() const {
2885 return _impl_.process_id_;
2886 }
process_id()2887 inline ::uint32_t Thread::process_id() const {
2888 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Thread.process_id)
2889 return _internal_process_id();
2890 }
_internal_set_process_id(::uint32_t value)2891 inline void Thread::_internal_set_process_id(::uint32_t value) {
2892 _impl_._has_bits_[0] |= 0x00000004u;
2893 _impl_.process_id_ = value;
2894 }
set_process_id(::uint32_t value)2895 inline void Thread::set_process_id(::uint32_t value) {
2896 _internal_set_process_id(value);
2897 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Thread.process_id)
2898 }
2899
2900 // optional string thread_name = 3;
_internal_has_thread_name()2901 inline bool Thread::_internal_has_thread_name() const {
2902 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2903 return value;
2904 }
has_thread_name()2905 inline bool Thread::has_thread_name() const {
2906 return _internal_has_thread_name();
2907 }
clear_thread_name()2908 inline void Thread::clear_thread_name() {
2909 _impl_.thread_name_.ClearToEmpty();
2910 _impl_._has_bits_[0] &= ~0x00000001u;
2911 }
thread_name()2912 inline const std::string& Thread::thread_name() const {
2913 // @@protoc_insertion_point(field_get:simpleperf_report_proto.Thread.thread_name)
2914 return _internal_thread_name();
2915 }
2916 template <typename ArgT0, typename... ArgT>
2917 inline PROTOBUF_ALWAYS_INLINE
set_thread_name(ArgT0 && arg0,ArgT...args)2918 void Thread::set_thread_name(ArgT0&& arg0, ArgT... args) {
2919 _impl_._has_bits_[0] |= 0x00000001u;
2920 _impl_.thread_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
2921 // @@protoc_insertion_point(field_set:simpleperf_report_proto.Thread.thread_name)
2922 }
mutable_thread_name()2923 inline std::string* Thread::mutable_thread_name() {
2924 std::string* _s = _internal_mutable_thread_name();
2925 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.Thread.thread_name)
2926 return _s;
2927 }
_internal_thread_name()2928 inline const std::string& Thread::_internal_thread_name() const {
2929 return _impl_.thread_name_.Get();
2930 }
_internal_set_thread_name(const std::string & value)2931 inline void Thread::_internal_set_thread_name(const std::string& value) {
2932 _impl_._has_bits_[0] |= 0x00000001u;
2933 _impl_.thread_name_.Set(value, GetArenaForAllocation());
2934 }
_internal_mutable_thread_name()2935 inline std::string* Thread::_internal_mutable_thread_name() {
2936 _impl_._has_bits_[0] |= 0x00000001u;
2937 return _impl_.thread_name_.Mutable(GetArenaForAllocation());
2938 }
release_thread_name()2939 inline std::string* Thread::release_thread_name() {
2940 // @@protoc_insertion_point(field_release:simpleperf_report_proto.Thread.thread_name)
2941 if (!_internal_has_thread_name()) {
2942 return nullptr;
2943 }
2944 _impl_._has_bits_[0] &= ~0x00000001u;
2945 auto* p = _impl_.thread_name_.Release();
2946 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2947 if (_impl_.thread_name_.IsDefault()) {
2948 _impl_.thread_name_.Set("", GetArenaForAllocation());
2949 }
2950 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2951 return p;
2952 }
set_allocated_thread_name(std::string * thread_name)2953 inline void Thread::set_allocated_thread_name(std::string* thread_name) {
2954 if (thread_name != nullptr) {
2955 _impl_._has_bits_[0] |= 0x00000001u;
2956 } else {
2957 _impl_._has_bits_[0] &= ~0x00000001u;
2958 }
2959 _impl_.thread_name_.SetAllocated(thread_name, GetArenaForAllocation());
2960 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
2961 if (_impl_.thread_name_.IsDefault()) {
2962 _impl_.thread_name_.Set("", GetArenaForAllocation());
2963 }
2964 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
2965 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.Thread.thread_name)
2966 }
2967
2968 // -------------------------------------------------------------------
2969
2970 // MetaInfo
2971
2972 // repeated string event_type = 1;
_internal_event_type_size()2973 inline int MetaInfo::_internal_event_type_size() const {
2974 return _impl_.event_type_.size();
2975 }
event_type_size()2976 inline int MetaInfo::event_type_size() const {
2977 return _internal_event_type_size();
2978 }
clear_event_type()2979 inline void MetaInfo::clear_event_type() {
2980 _impl_.event_type_.Clear();
2981 }
add_event_type()2982 inline std::string* MetaInfo::add_event_type() {
2983 std::string* _s = _internal_add_event_type();
2984 // @@protoc_insertion_point(field_add_mutable:simpleperf_report_proto.MetaInfo.event_type)
2985 return _s;
2986 }
_internal_event_type(int index)2987 inline const std::string& MetaInfo::_internal_event_type(int index) const {
2988 return _impl_.event_type_.Get(index);
2989 }
event_type(int index)2990 inline const std::string& MetaInfo::event_type(int index) const {
2991 // @@protoc_insertion_point(field_get:simpleperf_report_proto.MetaInfo.event_type)
2992 return _internal_event_type(index);
2993 }
mutable_event_type(int index)2994 inline std::string* MetaInfo::mutable_event_type(int index) {
2995 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.MetaInfo.event_type)
2996 return _impl_.event_type_.Mutable(index);
2997 }
set_event_type(int index,const std::string & value)2998 inline void MetaInfo::set_event_type(int index, const std::string& value) {
2999 _impl_.event_type_.Mutable(index)->assign(value);
3000 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.event_type)
3001 }
set_event_type(int index,std::string && value)3002 inline void MetaInfo::set_event_type(int index, std::string&& value) {
3003 _impl_.event_type_.Mutable(index)->assign(std::move(value));
3004 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.event_type)
3005 }
set_event_type(int index,const char * value)3006 inline void MetaInfo::set_event_type(int index, const char* value) {
3007 GOOGLE_DCHECK(value != nullptr);
3008 _impl_.event_type_.Mutable(index)->assign(value);
3009 // @@protoc_insertion_point(field_set_char:simpleperf_report_proto.MetaInfo.event_type)
3010 }
set_event_type(int index,const char * value,size_t size)3011 inline void MetaInfo::set_event_type(int index, const char* value, size_t size) {
3012 _impl_.event_type_.Mutable(index)->assign(
3013 reinterpret_cast<const char*>(value), size);
3014 // @@protoc_insertion_point(field_set_pointer:simpleperf_report_proto.MetaInfo.event_type)
3015 }
_internal_add_event_type()3016 inline std::string* MetaInfo::_internal_add_event_type() {
3017 return _impl_.event_type_.Add();
3018 }
add_event_type(const std::string & value)3019 inline void MetaInfo::add_event_type(const std::string& value) {
3020 _impl_.event_type_.Add()->assign(value);
3021 // @@protoc_insertion_point(field_add:simpleperf_report_proto.MetaInfo.event_type)
3022 }
add_event_type(std::string && value)3023 inline void MetaInfo::add_event_type(std::string&& value) {
3024 _impl_.event_type_.Add(std::move(value));
3025 // @@protoc_insertion_point(field_add:simpleperf_report_proto.MetaInfo.event_type)
3026 }
add_event_type(const char * value)3027 inline void MetaInfo::add_event_type(const char* value) {
3028 GOOGLE_DCHECK(value != nullptr);
3029 _impl_.event_type_.Add()->assign(value);
3030 // @@protoc_insertion_point(field_add_char:simpleperf_report_proto.MetaInfo.event_type)
3031 }
add_event_type(const char * value,size_t size)3032 inline void MetaInfo::add_event_type(const char* value, size_t size) {
3033 _impl_.event_type_.Add()->assign(reinterpret_cast<const char*>(value), size);
3034 // @@protoc_insertion_point(field_add_pointer:simpleperf_report_proto.MetaInfo.event_type)
3035 }
3036 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
event_type()3037 MetaInfo::event_type() const {
3038 // @@protoc_insertion_point(field_list:simpleperf_report_proto.MetaInfo.event_type)
3039 return _impl_.event_type_;
3040 }
3041 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_event_type()3042 MetaInfo::mutable_event_type() {
3043 // @@protoc_insertion_point(field_mutable_list:simpleperf_report_proto.MetaInfo.event_type)
3044 return &_impl_.event_type_;
3045 }
3046
3047 // optional string app_package_name = 2;
_internal_has_app_package_name()3048 inline bool MetaInfo::_internal_has_app_package_name() const {
3049 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
3050 return value;
3051 }
has_app_package_name()3052 inline bool MetaInfo::has_app_package_name() const {
3053 return _internal_has_app_package_name();
3054 }
clear_app_package_name()3055 inline void MetaInfo::clear_app_package_name() {
3056 _impl_.app_package_name_.ClearToEmpty();
3057 _impl_._has_bits_[0] &= ~0x00000001u;
3058 }
app_package_name()3059 inline const std::string& MetaInfo::app_package_name() const {
3060 // @@protoc_insertion_point(field_get:simpleperf_report_proto.MetaInfo.app_package_name)
3061 return _internal_app_package_name();
3062 }
3063 template <typename ArgT0, typename... ArgT>
3064 inline PROTOBUF_ALWAYS_INLINE
set_app_package_name(ArgT0 && arg0,ArgT...args)3065 void MetaInfo::set_app_package_name(ArgT0&& arg0, ArgT... args) {
3066 _impl_._has_bits_[0] |= 0x00000001u;
3067 _impl_.app_package_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3068 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.app_package_name)
3069 }
mutable_app_package_name()3070 inline std::string* MetaInfo::mutable_app_package_name() {
3071 std::string* _s = _internal_mutable_app_package_name();
3072 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.MetaInfo.app_package_name)
3073 return _s;
3074 }
_internal_app_package_name()3075 inline const std::string& MetaInfo::_internal_app_package_name() const {
3076 return _impl_.app_package_name_.Get();
3077 }
_internal_set_app_package_name(const std::string & value)3078 inline void MetaInfo::_internal_set_app_package_name(const std::string& value) {
3079 _impl_._has_bits_[0] |= 0x00000001u;
3080 _impl_.app_package_name_.Set(value, GetArenaForAllocation());
3081 }
_internal_mutable_app_package_name()3082 inline std::string* MetaInfo::_internal_mutable_app_package_name() {
3083 _impl_._has_bits_[0] |= 0x00000001u;
3084 return _impl_.app_package_name_.Mutable(GetArenaForAllocation());
3085 }
release_app_package_name()3086 inline std::string* MetaInfo::release_app_package_name() {
3087 // @@protoc_insertion_point(field_release:simpleperf_report_proto.MetaInfo.app_package_name)
3088 if (!_internal_has_app_package_name()) {
3089 return nullptr;
3090 }
3091 _impl_._has_bits_[0] &= ~0x00000001u;
3092 auto* p = _impl_.app_package_name_.Release();
3093 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3094 if (_impl_.app_package_name_.IsDefault()) {
3095 _impl_.app_package_name_.Set("", GetArenaForAllocation());
3096 }
3097 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3098 return p;
3099 }
set_allocated_app_package_name(std::string * app_package_name)3100 inline void MetaInfo::set_allocated_app_package_name(std::string* app_package_name) {
3101 if (app_package_name != nullptr) {
3102 _impl_._has_bits_[0] |= 0x00000001u;
3103 } else {
3104 _impl_._has_bits_[0] &= ~0x00000001u;
3105 }
3106 _impl_.app_package_name_.SetAllocated(app_package_name, GetArenaForAllocation());
3107 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3108 if (_impl_.app_package_name_.IsDefault()) {
3109 _impl_.app_package_name_.Set("", GetArenaForAllocation());
3110 }
3111 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3112 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.MetaInfo.app_package_name)
3113 }
3114
3115 // optional string app_type = 3;
_internal_has_app_type()3116 inline bool MetaInfo::_internal_has_app_type() const {
3117 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3118 return value;
3119 }
has_app_type()3120 inline bool MetaInfo::has_app_type() const {
3121 return _internal_has_app_type();
3122 }
clear_app_type()3123 inline void MetaInfo::clear_app_type() {
3124 _impl_.app_type_.ClearToEmpty();
3125 _impl_._has_bits_[0] &= ~0x00000002u;
3126 }
app_type()3127 inline const std::string& MetaInfo::app_type() const {
3128 // @@protoc_insertion_point(field_get:simpleperf_report_proto.MetaInfo.app_type)
3129 return _internal_app_type();
3130 }
3131 template <typename ArgT0, typename... ArgT>
3132 inline PROTOBUF_ALWAYS_INLINE
set_app_type(ArgT0 && arg0,ArgT...args)3133 void MetaInfo::set_app_type(ArgT0&& arg0, ArgT... args) {
3134 _impl_._has_bits_[0] |= 0x00000002u;
3135 _impl_.app_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3136 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.app_type)
3137 }
mutable_app_type()3138 inline std::string* MetaInfo::mutable_app_type() {
3139 std::string* _s = _internal_mutable_app_type();
3140 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.MetaInfo.app_type)
3141 return _s;
3142 }
_internal_app_type()3143 inline const std::string& MetaInfo::_internal_app_type() const {
3144 return _impl_.app_type_.Get();
3145 }
_internal_set_app_type(const std::string & value)3146 inline void MetaInfo::_internal_set_app_type(const std::string& value) {
3147 _impl_._has_bits_[0] |= 0x00000002u;
3148 _impl_.app_type_.Set(value, GetArenaForAllocation());
3149 }
_internal_mutable_app_type()3150 inline std::string* MetaInfo::_internal_mutable_app_type() {
3151 _impl_._has_bits_[0] |= 0x00000002u;
3152 return _impl_.app_type_.Mutable(GetArenaForAllocation());
3153 }
release_app_type()3154 inline std::string* MetaInfo::release_app_type() {
3155 // @@protoc_insertion_point(field_release:simpleperf_report_proto.MetaInfo.app_type)
3156 if (!_internal_has_app_type()) {
3157 return nullptr;
3158 }
3159 _impl_._has_bits_[0] &= ~0x00000002u;
3160 auto* p = _impl_.app_type_.Release();
3161 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3162 if (_impl_.app_type_.IsDefault()) {
3163 _impl_.app_type_.Set("", GetArenaForAllocation());
3164 }
3165 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3166 return p;
3167 }
set_allocated_app_type(std::string * app_type)3168 inline void MetaInfo::set_allocated_app_type(std::string* app_type) {
3169 if (app_type != nullptr) {
3170 _impl_._has_bits_[0] |= 0x00000002u;
3171 } else {
3172 _impl_._has_bits_[0] &= ~0x00000002u;
3173 }
3174 _impl_.app_type_.SetAllocated(app_type, GetArenaForAllocation());
3175 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3176 if (_impl_.app_type_.IsDefault()) {
3177 _impl_.app_type_.Set("", GetArenaForAllocation());
3178 }
3179 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3180 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.MetaInfo.app_type)
3181 }
3182
3183 // optional string android_sdk_version = 4;
_internal_has_android_sdk_version()3184 inline bool MetaInfo::_internal_has_android_sdk_version() const {
3185 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
3186 return value;
3187 }
has_android_sdk_version()3188 inline bool MetaInfo::has_android_sdk_version() const {
3189 return _internal_has_android_sdk_version();
3190 }
clear_android_sdk_version()3191 inline void MetaInfo::clear_android_sdk_version() {
3192 _impl_.android_sdk_version_.ClearToEmpty();
3193 _impl_._has_bits_[0] &= ~0x00000004u;
3194 }
android_sdk_version()3195 inline const std::string& MetaInfo::android_sdk_version() const {
3196 // @@protoc_insertion_point(field_get:simpleperf_report_proto.MetaInfo.android_sdk_version)
3197 return _internal_android_sdk_version();
3198 }
3199 template <typename ArgT0, typename... ArgT>
3200 inline PROTOBUF_ALWAYS_INLINE
set_android_sdk_version(ArgT0 && arg0,ArgT...args)3201 void MetaInfo::set_android_sdk_version(ArgT0&& arg0, ArgT... args) {
3202 _impl_._has_bits_[0] |= 0x00000004u;
3203 _impl_.android_sdk_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3204 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.android_sdk_version)
3205 }
mutable_android_sdk_version()3206 inline std::string* MetaInfo::mutable_android_sdk_version() {
3207 std::string* _s = _internal_mutable_android_sdk_version();
3208 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.MetaInfo.android_sdk_version)
3209 return _s;
3210 }
_internal_android_sdk_version()3211 inline const std::string& MetaInfo::_internal_android_sdk_version() const {
3212 return _impl_.android_sdk_version_.Get();
3213 }
_internal_set_android_sdk_version(const std::string & value)3214 inline void MetaInfo::_internal_set_android_sdk_version(const std::string& value) {
3215 _impl_._has_bits_[0] |= 0x00000004u;
3216 _impl_.android_sdk_version_.Set(value, GetArenaForAllocation());
3217 }
_internal_mutable_android_sdk_version()3218 inline std::string* MetaInfo::_internal_mutable_android_sdk_version() {
3219 _impl_._has_bits_[0] |= 0x00000004u;
3220 return _impl_.android_sdk_version_.Mutable(GetArenaForAllocation());
3221 }
release_android_sdk_version()3222 inline std::string* MetaInfo::release_android_sdk_version() {
3223 // @@protoc_insertion_point(field_release:simpleperf_report_proto.MetaInfo.android_sdk_version)
3224 if (!_internal_has_android_sdk_version()) {
3225 return nullptr;
3226 }
3227 _impl_._has_bits_[0] &= ~0x00000004u;
3228 auto* p = _impl_.android_sdk_version_.Release();
3229 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3230 if (_impl_.android_sdk_version_.IsDefault()) {
3231 _impl_.android_sdk_version_.Set("", GetArenaForAllocation());
3232 }
3233 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3234 return p;
3235 }
set_allocated_android_sdk_version(std::string * android_sdk_version)3236 inline void MetaInfo::set_allocated_android_sdk_version(std::string* android_sdk_version) {
3237 if (android_sdk_version != nullptr) {
3238 _impl_._has_bits_[0] |= 0x00000004u;
3239 } else {
3240 _impl_._has_bits_[0] &= ~0x00000004u;
3241 }
3242 _impl_.android_sdk_version_.SetAllocated(android_sdk_version, GetArenaForAllocation());
3243 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3244 if (_impl_.android_sdk_version_.IsDefault()) {
3245 _impl_.android_sdk_version_.Set("", GetArenaForAllocation());
3246 }
3247 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3248 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.MetaInfo.android_sdk_version)
3249 }
3250
3251 // optional string android_build_type = 5;
_internal_has_android_build_type()3252 inline bool MetaInfo::_internal_has_android_build_type() const {
3253 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
3254 return value;
3255 }
has_android_build_type()3256 inline bool MetaInfo::has_android_build_type() const {
3257 return _internal_has_android_build_type();
3258 }
clear_android_build_type()3259 inline void MetaInfo::clear_android_build_type() {
3260 _impl_.android_build_type_.ClearToEmpty();
3261 _impl_._has_bits_[0] &= ~0x00000008u;
3262 }
android_build_type()3263 inline const std::string& MetaInfo::android_build_type() const {
3264 // @@protoc_insertion_point(field_get:simpleperf_report_proto.MetaInfo.android_build_type)
3265 return _internal_android_build_type();
3266 }
3267 template <typename ArgT0, typename... ArgT>
3268 inline PROTOBUF_ALWAYS_INLINE
set_android_build_type(ArgT0 && arg0,ArgT...args)3269 void MetaInfo::set_android_build_type(ArgT0&& arg0, ArgT... args) {
3270 _impl_._has_bits_[0] |= 0x00000008u;
3271 _impl_.android_build_type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
3272 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.android_build_type)
3273 }
mutable_android_build_type()3274 inline std::string* MetaInfo::mutable_android_build_type() {
3275 std::string* _s = _internal_mutable_android_build_type();
3276 // @@protoc_insertion_point(field_mutable:simpleperf_report_proto.MetaInfo.android_build_type)
3277 return _s;
3278 }
_internal_android_build_type()3279 inline const std::string& MetaInfo::_internal_android_build_type() const {
3280 return _impl_.android_build_type_.Get();
3281 }
_internal_set_android_build_type(const std::string & value)3282 inline void MetaInfo::_internal_set_android_build_type(const std::string& value) {
3283 _impl_._has_bits_[0] |= 0x00000008u;
3284 _impl_.android_build_type_.Set(value, GetArenaForAllocation());
3285 }
_internal_mutable_android_build_type()3286 inline std::string* MetaInfo::_internal_mutable_android_build_type() {
3287 _impl_._has_bits_[0] |= 0x00000008u;
3288 return _impl_.android_build_type_.Mutable(GetArenaForAllocation());
3289 }
release_android_build_type()3290 inline std::string* MetaInfo::release_android_build_type() {
3291 // @@protoc_insertion_point(field_release:simpleperf_report_proto.MetaInfo.android_build_type)
3292 if (!_internal_has_android_build_type()) {
3293 return nullptr;
3294 }
3295 _impl_._has_bits_[0] &= ~0x00000008u;
3296 auto* p = _impl_.android_build_type_.Release();
3297 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3298 if (_impl_.android_build_type_.IsDefault()) {
3299 _impl_.android_build_type_.Set("", GetArenaForAllocation());
3300 }
3301 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3302 return p;
3303 }
set_allocated_android_build_type(std::string * android_build_type)3304 inline void MetaInfo::set_allocated_android_build_type(std::string* android_build_type) {
3305 if (android_build_type != nullptr) {
3306 _impl_._has_bits_[0] |= 0x00000008u;
3307 } else {
3308 _impl_._has_bits_[0] &= ~0x00000008u;
3309 }
3310 _impl_.android_build_type_.SetAllocated(android_build_type, GetArenaForAllocation());
3311 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
3312 if (_impl_.android_build_type_.IsDefault()) {
3313 _impl_.android_build_type_.Set("", GetArenaForAllocation());
3314 }
3315 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
3316 // @@protoc_insertion_point(field_set_allocated:simpleperf_report_proto.MetaInfo.android_build_type)
3317 }
3318
3319 // optional bool trace_offcpu = 6;
_internal_has_trace_offcpu()3320 inline bool MetaInfo::_internal_has_trace_offcpu() const {
3321 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
3322 return value;
3323 }
has_trace_offcpu()3324 inline bool MetaInfo::has_trace_offcpu() const {
3325 return _internal_has_trace_offcpu();
3326 }
clear_trace_offcpu()3327 inline void MetaInfo::clear_trace_offcpu() {
3328 _impl_.trace_offcpu_ = false;
3329 _impl_._has_bits_[0] &= ~0x00000010u;
3330 }
_internal_trace_offcpu()3331 inline bool MetaInfo::_internal_trace_offcpu() const {
3332 return _impl_.trace_offcpu_;
3333 }
trace_offcpu()3334 inline bool MetaInfo::trace_offcpu() const {
3335 // @@protoc_insertion_point(field_get:simpleperf_report_proto.MetaInfo.trace_offcpu)
3336 return _internal_trace_offcpu();
3337 }
_internal_set_trace_offcpu(bool value)3338 inline void MetaInfo::_internal_set_trace_offcpu(bool value) {
3339 _impl_._has_bits_[0] |= 0x00000010u;
3340 _impl_.trace_offcpu_ = value;
3341 }
set_trace_offcpu(bool value)3342 inline void MetaInfo::set_trace_offcpu(bool value) {
3343 _internal_set_trace_offcpu(value);
3344 // @@protoc_insertion_point(field_set:simpleperf_report_proto.MetaInfo.trace_offcpu)
3345 }
3346
3347 // -------------------------------------------------------------------
3348
3349 // ContextSwitch
3350
3351 // optional bool switch_on = 1;
_internal_has_switch_on()3352 inline bool ContextSwitch::_internal_has_switch_on() const {
3353 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
3354 return value;
3355 }
has_switch_on()3356 inline bool ContextSwitch::has_switch_on() const {
3357 return _internal_has_switch_on();
3358 }
clear_switch_on()3359 inline void ContextSwitch::clear_switch_on() {
3360 _impl_.switch_on_ = false;
3361 _impl_._has_bits_[0] &= ~0x00000002u;
3362 }
_internal_switch_on()3363 inline bool ContextSwitch::_internal_switch_on() const {
3364 return _impl_.switch_on_;
3365 }
switch_on()3366