1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/config/ftrace/ftrace_config.proto
3
4 #ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto
5 #define GOOGLE_PROTOBUF_INCLUDED_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_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_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_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_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto {
44 static const ::uint32_t offsets[];
45 };
46 namespace perfetto {
47 namespace protos {
48 class FtraceConfig;
49 struct FtraceConfigDefaultTypeInternal;
50 extern FtraceConfigDefaultTypeInternal _FtraceConfig_default_instance_;
51 class FtraceConfig_CompactSchedConfig;
52 struct FtraceConfig_CompactSchedConfigDefaultTypeInternal;
53 extern FtraceConfig_CompactSchedConfigDefaultTypeInternal _FtraceConfig_CompactSchedConfig_default_instance_;
54 class FtraceConfig_KprobeEvent;
55 struct FtraceConfig_KprobeEventDefaultTypeInternal;
56 extern FtraceConfig_KprobeEventDefaultTypeInternal _FtraceConfig_KprobeEvent_default_instance_;
57 class FtraceConfig_PrintFilter;
58 struct FtraceConfig_PrintFilterDefaultTypeInternal;
59 extern FtraceConfig_PrintFilterDefaultTypeInternal _FtraceConfig_PrintFilter_default_instance_;
60 class FtraceConfig_PrintFilter_Rule;
61 struct FtraceConfig_PrintFilter_RuleDefaultTypeInternal;
62 extern FtraceConfig_PrintFilter_RuleDefaultTypeInternal _FtraceConfig_PrintFilter_Rule_default_instance_;
63 class FtraceConfig_PrintFilter_Rule_AtraceMessage;
64 struct FtraceConfig_PrintFilter_Rule_AtraceMessageDefaultTypeInternal;
65 extern FtraceConfig_PrintFilter_Rule_AtraceMessageDefaultTypeInternal _FtraceConfig_PrintFilter_Rule_AtraceMessage_default_instance_;
66 } // namespace protos
67 } // namespace perfetto
68 PROTOBUF_NAMESPACE_OPEN
69 template<> ::perfetto::protos::FtraceConfig* Arena::CreateMaybeMessage<::perfetto::protos::FtraceConfig>(Arena*);
70 template<> ::perfetto::protos::FtraceConfig_CompactSchedConfig* Arena::CreateMaybeMessage<::perfetto::protos::FtraceConfig_CompactSchedConfig>(Arena*);
71 template<> ::perfetto::protos::FtraceConfig_KprobeEvent* Arena::CreateMaybeMessage<::perfetto::protos::FtraceConfig_KprobeEvent>(Arena*);
72 template<> ::perfetto::protos::FtraceConfig_PrintFilter* Arena::CreateMaybeMessage<::perfetto::protos::FtraceConfig_PrintFilter>(Arena*);
73 template<> ::perfetto::protos::FtraceConfig_PrintFilter_Rule* Arena::CreateMaybeMessage<::perfetto::protos::FtraceConfig_PrintFilter_Rule>(Arena*);
74 template<> ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* Arena::CreateMaybeMessage<::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage>(Arena*);
75 PROTOBUF_NAMESPACE_CLOSE
76 namespace perfetto {
77 namespace protos {
78
79 enum FtraceConfig_KprobeEvent_KprobeType : int {
80 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_UNKNOWN = 0,
81 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KPROBE = 1,
82 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KRETPROBE = 2,
83 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_BOTH = 3
84 };
85 bool FtraceConfig_KprobeEvent_KprobeType_IsValid(int value);
86 constexpr FtraceConfig_KprobeEvent_KprobeType FtraceConfig_KprobeEvent_KprobeType_KprobeType_MIN = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_UNKNOWN;
87 constexpr FtraceConfig_KprobeEvent_KprobeType FtraceConfig_KprobeEvent_KprobeType_KprobeType_MAX = FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_BOTH;
88 constexpr int FtraceConfig_KprobeEvent_KprobeType_KprobeType_ARRAYSIZE = FtraceConfig_KprobeEvent_KprobeType_KprobeType_MAX + 1;
89
90 const std::string& FtraceConfig_KprobeEvent_KprobeType_Name(FtraceConfig_KprobeEvent_KprobeType value);
91 template<typename T>
FtraceConfig_KprobeEvent_KprobeType_Name(T enum_t_value)92 inline const std::string& FtraceConfig_KprobeEvent_KprobeType_Name(T enum_t_value) {
93 static_assert(::std::is_same<T, FtraceConfig_KprobeEvent_KprobeType>::value ||
94 ::std::is_integral<T>::value,
95 "Incorrect type passed to function FtraceConfig_KprobeEvent_KprobeType_Name.");
96 return FtraceConfig_KprobeEvent_KprobeType_Name(static_cast<FtraceConfig_KprobeEvent_KprobeType>(enum_t_value));
97 }
98 bool FtraceConfig_KprobeEvent_KprobeType_Parse(
99 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FtraceConfig_KprobeEvent_KprobeType* value);
100 enum FtraceConfig_KsymsMemPolicy : int {
101 FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED = 0,
102 FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP = 1,
103 FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN = 2
104 };
105 bool FtraceConfig_KsymsMemPolicy_IsValid(int value);
106 constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_MIN = FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
107 constexpr FtraceConfig_KsymsMemPolicy FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_MAX = FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
108 constexpr int FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_ARRAYSIZE = FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_MAX + 1;
109
110 const std::string& FtraceConfig_KsymsMemPolicy_Name(FtraceConfig_KsymsMemPolicy value);
111 template<typename T>
FtraceConfig_KsymsMemPolicy_Name(T enum_t_value)112 inline const std::string& FtraceConfig_KsymsMemPolicy_Name(T enum_t_value) {
113 static_assert(::std::is_same<T, FtraceConfig_KsymsMemPolicy>::value ||
114 ::std::is_integral<T>::value,
115 "Incorrect type passed to function FtraceConfig_KsymsMemPolicy_Name.");
116 return FtraceConfig_KsymsMemPolicy_Name(static_cast<FtraceConfig_KsymsMemPolicy>(enum_t_value));
117 }
118 bool FtraceConfig_KsymsMemPolicy_Parse(
119 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FtraceConfig_KsymsMemPolicy* value);
120 // ===================================================================
121
122 class FtraceConfig_KprobeEvent final :
123 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FtraceConfig.KprobeEvent) */ {
124 public:
FtraceConfig_KprobeEvent()125 inline FtraceConfig_KprobeEvent() : FtraceConfig_KprobeEvent(nullptr) {}
126 ~FtraceConfig_KprobeEvent() override;
127 explicit PROTOBUF_CONSTEXPR FtraceConfig_KprobeEvent(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
128
129 FtraceConfig_KprobeEvent(const FtraceConfig_KprobeEvent& from);
FtraceConfig_KprobeEvent(FtraceConfig_KprobeEvent && from)130 FtraceConfig_KprobeEvent(FtraceConfig_KprobeEvent&& from) noexcept
131 : FtraceConfig_KprobeEvent() {
132 *this = ::std::move(from);
133 }
134
135 inline FtraceConfig_KprobeEvent& operator=(const FtraceConfig_KprobeEvent& from) {
136 if (this == &from) return *this;
137 CopyFrom(from);
138 return *this;
139 }
140 inline FtraceConfig_KprobeEvent& operator=(FtraceConfig_KprobeEvent&& from) noexcept {
141 if (this == &from) return *this;
142 if (GetOwningArena() == from.GetOwningArena()
143 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
144 && GetOwningArena() != nullptr
145 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
146 ) {
147 InternalSwap(&from);
148 } else {
149 CopyFrom(from);
150 }
151 return *this;
152 }
153
unknown_fields()154 inline const std::string& unknown_fields() const {
155 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
156 }
mutable_unknown_fields()157 inline std::string* mutable_unknown_fields() {
158 return _internal_metadata_.mutable_unknown_fields<std::string>();
159 }
160
default_instance()161 static const FtraceConfig_KprobeEvent& default_instance() {
162 return *internal_default_instance();
163 }
internal_default_instance()164 static inline const FtraceConfig_KprobeEvent* internal_default_instance() {
165 return reinterpret_cast<const FtraceConfig_KprobeEvent*>(
166 &_FtraceConfig_KprobeEvent_default_instance_);
167 }
168 static constexpr int kIndexInFileMessages =
169 0;
170
swap(FtraceConfig_KprobeEvent & a,FtraceConfig_KprobeEvent & b)171 friend void swap(FtraceConfig_KprobeEvent& a, FtraceConfig_KprobeEvent& b) {
172 a.Swap(&b);
173 }
Swap(FtraceConfig_KprobeEvent * other)174 inline void Swap(FtraceConfig_KprobeEvent* other) {
175 if (other == this) return;
176 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
177 if (GetOwningArena() != nullptr &&
178 GetOwningArena() == other->GetOwningArena()) {
179 #else // PROTOBUF_FORCE_COPY_IN_SWAP
180 if (GetOwningArena() == other->GetOwningArena()) {
181 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
182 InternalSwap(other);
183 } else {
184 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
185 }
186 }
187 void UnsafeArenaSwap(FtraceConfig_KprobeEvent* other) {
188 if (other == this) return;
189 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
190 InternalSwap(other);
191 }
192
193 // implements Message ----------------------------------------------
194
195 FtraceConfig_KprobeEvent* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
196 return CreateMaybeMessage<FtraceConfig_KprobeEvent>(arena);
197 }
198 FtraceConfig_KprobeEvent* New() const {
199 return New(nullptr);
200 }
201 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
202 void CopyFrom(const FtraceConfig_KprobeEvent& from);
203 void MergeFrom(const FtraceConfig_KprobeEvent& from);
204 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
205 bool IsInitialized() const final;
206
207 size_t ByteSizeLong() const final;
208 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
209 ::uint8_t* _InternalSerialize(
210 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
211 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
212
213 private:
214 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
215 void SharedDtor();
216 void SetCachedSize(int size) const;
217 void InternalSwap(FtraceConfig_KprobeEvent* other);
218
219 private:
220 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
221 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
222 return "perfetto.protos.FtraceConfig.KprobeEvent";
223 }
224 protected:
225 explicit FtraceConfig_KprobeEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
226 bool is_message_owned = false);
227 public:
228
229 std::string GetTypeName() const final;
230
231 // nested types ----------------------------------------------------
232
233 typedef FtraceConfig_KprobeEvent_KprobeType KprobeType;
234 static constexpr KprobeType KPROBE_TYPE_UNKNOWN =
235 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_UNKNOWN;
236 static constexpr KprobeType KPROBE_TYPE_KPROBE =
237 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KPROBE;
238 static constexpr KprobeType KPROBE_TYPE_KRETPROBE =
239 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_KRETPROBE;
240 static constexpr KprobeType KPROBE_TYPE_BOTH =
241 FtraceConfig_KprobeEvent_KprobeType_KPROBE_TYPE_BOTH;
242 static inline bool KprobeType_IsValid(int value) {
243 return FtraceConfig_KprobeEvent_KprobeType_IsValid(value);
244 }
245 static constexpr KprobeType KprobeType_MIN =
246 FtraceConfig_KprobeEvent_KprobeType_KprobeType_MIN;
247 static constexpr KprobeType KprobeType_MAX =
248 FtraceConfig_KprobeEvent_KprobeType_KprobeType_MAX;
249 static constexpr int KprobeType_ARRAYSIZE =
250 FtraceConfig_KprobeEvent_KprobeType_KprobeType_ARRAYSIZE;
251 template<typename T>
252 static inline const std::string& KprobeType_Name(T enum_t_value) {
253 static_assert(::std::is_same<T, KprobeType>::value ||
254 ::std::is_integral<T>::value,
255 "Incorrect type passed to function KprobeType_Name.");
256 return FtraceConfig_KprobeEvent_KprobeType_Name(enum_t_value);
257 }
258 static inline bool KprobeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
259 KprobeType* value) {
260 return FtraceConfig_KprobeEvent_KprobeType_Parse(name, value);
261 }
262
263 // accessors -------------------------------------------------------
264
265 enum : int {
266 kProbeFieldNumber = 1,
267 kTypeFieldNumber = 2,
268 };
269 // optional string probe = 1;
270 bool has_probe() const;
271 private:
272 bool _internal_has_probe() const;
273 public:
274 void clear_probe();
275 const std::string& probe() const;
276 template <typename ArgT0 = const std::string&, typename... ArgT>
277 void set_probe(ArgT0&& arg0, ArgT... args);
278 std::string* mutable_probe();
279 PROTOBUF_NODISCARD std::string* release_probe();
280 void set_allocated_probe(std::string* probe);
281 private:
282 const std::string& _internal_probe() const;
283 inline PROTOBUF_ALWAYS_INLINE void _internal_set_probe(const std::string& value);
284 std::string* _internal_mutable_probe();
285 public:
286
287 // optional .perfetto.protos.FtraceConfig.KprobeEvent.KprobeType type = 2;
288 bool has_type() const;
289 private:
290 bool _internal_has_type() const;
291 public:
292 void clear_type();
293 ::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType type() const;
294 void set_type(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType value);
295 private:
296 ::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType _internal_type() const;
297 void _internal_set_type(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType value);
298 public:
299
300 // @@protoc_insertion_point(class_scope:perfetto.protos.FtraceConfig.KprobeEvent)
301 private:
302 class _Internal;
303
304 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
305 typedef void InternalArenaConstructable_;
306 typedef void DestructorSkippable_;
307 struct Impl_ {
308 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
309 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
310 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr probe_;
311 int type_;
312 };
313 union { Impl_ _impl_; };
314 friend struct ::TableStruct_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto;
315 };
316 // -------------------------------------------------------------------
317
318 class FtraceConfig_CompactSchedConfig final :
319 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FtraceConfig.CompactSchedConfig) */ {
320 public:
FtraceConfig_CompactSchedConfig()321 inline FtraceConfig_CompactSchedConfig() : FtraceConfig_CompactSchedConfig(nullptr) {}
322 ~FtraceConfig_CompactSchedConfig() override;
323 explicit PROTOBUF_CONSTEXPR FtraceConfig_CompactSchedConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
324
325 FtraceConfig_CompactSchedConfig(const FtraceConfig_CompactSchedConfig& from);
FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig && from)326 FtraceConfig_CompactSchedConfig(FtraceConfig_CompactSchedConfig&& from) noexcept
327 : FtraceConfig_CompactSchedConfig() {
328 *this = ::std::move(from);
329 }
330
331 inline FtraceConfig_CompactSchedConfig& operator=(const FtraceConfig_CompactSchedConfig& from) {
332 if (this == &from) return *this;
333 CopyFrom(from);
334 return *this;
335 }
336 inline FtraceConfig_CompactSchedConfig& operator=(FtraceConfig_CompactSchedConfig&& from) noexcept {
337 if (this == &from) return *this;
338 if (GetOwningArena() == from.GetOwningArena()
339 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
340 && GetOwningArena() != nullptr
341 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
342 ) {
343 InternalSwap(&from);
344 } else {
345 CopyFrom(from);
346 }
347 return *this;
348 }
349
unknown_fields()350 inline const std::string& unknown_fields() const {
351 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
352 }
mutable_unknown_fields()353 inline std::string* mutable_unknown_fields() {
354 return _internal_metadata_.mutable_unknown_fields<std::string>();
355 }
356
default_instance()357 static const FtraceConfig_CompactSchedConfig& default_instance() {
358 return *internal_default_instance();
359 }
internal_default_instance()360 static inline const FtraceConfig_CompactSchedConfig* internal_default_instance() {
361 return reinterpret_cast<const FtraceConfig_CompactSchedConfig*>(
362 &_FtraceConfig_CompactSchedConfig_default_instance_);
363 }
364 static constexpr int kIndexInFileMessages =
365 1;
366
swap(FtraceConfig_CompactSchedConfig & a,FtraceConfig_CompactSchedConfig & b)367 friend void swap(FtraceConfig_CompactSchedConfig& a, FtraceConfig_CompactSchedConfig& b) {
368 a.Swap(&b);
369 }
Swap(FtraceConfig_CompactSchedConfig * other)370 inline void Swap(FtraceConfig_CompactSchedConfig* other) {
371 if (other == this) return;
372 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
373 if (GetOwningArena() != nullptr &&
374 GetOwningArena() == other->GetOwningArena()) {
375 #else // PROTOBUF_FORCE_COPY_IN_SWAP
376 if (GetOwningArena() == other->GetOwningArena()) {
377 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
378 InternalSwap(other);
379 } else {
380 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
381 }
382 }
383 void UnsafeArenaSwap(FtraceConfig_CompactSchedConfig* other) {
384 if (other == this) return;
385 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
386 InternalSwap(other);
387 }
388
389 // implements Message ----------------------------------------------
390
391 FtraceConfig_CompactSchedConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
392 return CreateMaybeMessage<FtraceConfig_CompactSchedConfig>(arena);
393 }
394 FtraceConfig_CompactSchedConfig* New() const {
395 return New(nullptr);
396 }
397 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
398 void CopyFrom(const FtraceConfig_CompactSchedConfig& from);
399 void MergeFrom(const FtraceConfig_CompactSchedConfig& from);
400 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
401 bool IsInitialized() const final;
402
403 size_t ByteSizeLong() const final;
404 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
405 ::uint8_t* _InternalSerialize(
406 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
407 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
408
409 private:
410 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
411 void SharedDtor();
412 void SetCachedSize(int size) const;
413 void InternalSwap(FtraceConfig_CompactSchedConfig* other);
414
415 private:
416 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
417 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
418 return "perfetto.protos.FtraceConfig.CompactSchedConfig";
419 }
420 protected:
421 explicit FtraceConfig_CompactSchedConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
422 bool is_message_owned = false);
423 public:
424
425 std::string GetTypeName() const final;
426
427 // nested types ----------------------------------------------------
428
429 // accessors -------------------------------------------------------
430
431 enum : int {
432 kEnabledFieldNumber = 1,
433 };
434 // optional bool enabled = 1;
435 bool has_enabled() const;
436 private:
437 bool _internal_has_enabled() const;
438 public:
439 void clear_enabled();
440 bool enabled() const;
441 void set_enabled(bool value);
442 private:
443 bool _internal_enabled() const;
444 void _internal_set_enabled(bool value);
445 public:
446
447 // @@protoc_insertion_point(class_scope:perfetto.protos.FtraceConfig.CompactSchedConfig)
448 private:
449 class _Internal;
450
451 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
452 typedef void InternalArenaConstructable_;
453 typedef void DestructorSkippable_;
454 struct Impl_ {
455 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
456 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
457 bool enabled_;
458 };
459 union { Impl_ _impl_; };
460 friend struct ::TableStruct_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto;
461 };
462 // -------------------------------------------------------------------
463
464 class FtraceConfig_PrintFilter_Rule_AtraceMessage final :
465 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage) */ {
466 public:
FtraceConfig_PrintFilter_Rule_AtraceMessage()467 inline FtraceConfig_PrintFilter_Rule_AtraceMessage() : FtraceConfig_PrintFilter_Rule_AtraceMessage(nullptr) {}
468 ~FtraceConfig_PrintFilter_Rule_AtraceMessage() override;
469 explicit PROTOBUF_CONSTEXPR FtraceConfig_PrintFilter_Rule_AtraceMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
470
471 FtraceConfig_PrintFilter_Rule_AtraceMessage(const FtraceConfig_PrintFilter_Rule_AtraceMessage& from);
FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage && from)472 FtraceConfig_PrintFilter_Rule_AtraceMessage(FtraceConfig_PrintFilter_Rule_AtraceMessage&& from) noexcept
473 : FtraceConfig_PrintFilter_Rule_AtraceMessage() {
474 *this = ::std::move(from);
475 }
476
477 inline FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(const FtraceConfig_PrintFilter_Rule_AtraceMessage& from) {
478 if (this == &from) return *this;
479 CopyFrom(from);
480 return *this;
481 }
482 inline FtraceConfig_PrintFilter_Rule_AtraceMessage& operator=(FtraceConfig_PrintFilter_Rule_AtraceMessage&& from) noexcept {
483 if (this == &from) return *this;
484 if (GetOwningArena() == from.GetOwningArena()
485 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
486 && GetOwningArena() != nullptr
487 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
488 ) {
489 InternalSwap(&from);
490 } else {
491 CopyFrom(from);
492 }
493 return *this;
494 }
495
unknown_fields()496 inline const std::string& unknown_fields() const {
497 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
498 }
mutable_unknown_fields()499 inline std::string* mutable_unknown_fields() {
500 return _internal_metadata_.mutable_unknown_fields<std::string>();
501 }
502
default_instance()503 static const FtraceConfig_PrintFilter_Rule_AtraceMessage& default_instance() {
504 return *internal_default_instance();
505 }
internal_default_instance()506 static inline const FtraceConfig_PrintFilter_Rule_AtraceMessage* internal_default_instance() {
507 return reinterpret_cast<const FtraceConfig_PrintFilter_Rule_AtraceMessage*>(
508 &_FtraceConfig_PrintFilter_Rule_AtraceMessage_default_instance_);
509 }
510 static constexpr int kIndexInFileMessages =
511 2;
512
swap(FtraceConfig_PrintFilter_Rule_AtraceMessage & a,FtraceConfig_PrintFilter_Rule_AtraceMessage & b)513 friend void swap(FtraceConfig_PrintFilter_Rule_AtraceMessage& a, FtraceConfig_PrintFilter_Rule_AtraceMessage& b) {
514 a.Swap(&b);
515 }
Swap(FtraceConfig_PrintFilter_Rule_AtraceMessage * other)516 inline void Swap(FtraceConfig_PrintFilter_Rule_AtraceMessage* other) {
517 if (other == this) return;
518 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
519 if (GetOwningArena() != nullptr &&
520 GetOwningArena() == other->GetOwningArena()) {
521 #else // PROTOBUF_FORCE_COPY_IN_SWAP
522 if (GetOwningArena() == other->GetOwningArena()) {
523 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
524 InternalSwap(other);
525 } else {
526 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
527 }
528 }
529 void UnsafeArenaSwap(FtraceConfig_PrintFilter_Rule_AtraceMessage* other) {
530 if (other == this) return;
531 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
532 InternalSwap(other);
533 }
534
535 // implements Message ----------------------------------------------
536
537 FtraceConfig_PrintFilter_Rule_AtraceMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
538 return CreateMaybeMessage<FtraceConfig_PrintFilter_Rule_AtraceMessage>(arena);
539 }
540 FtraceConfig_PrintFilter_Rule_AtraceMessage* New() const {
541 return New(nullptr);
542 }
543 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
544 void CopyFrom(const FtraceConfig_PrintFilter_Rule_AtraceMessage& from);
545 void MergeFrom(const FtraceConfig_PrintFilter_Rule_AtraceMessage& from);
546 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
547 bool IsInitialized() const final;
548
549 size_t ByteSizeLong() const final;
550 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
551 ::uint8_t* _InternalSerialize(
552 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
553 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
554
555 private:
556 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
557 void SharedDtor();
558 void SetCachedSize(int size) const;
559 void InternalSwap(FtraceConfig_PrintFilter_Rule_AtraceMessage* other);
560
561 private:
562 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
563 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
564 return "perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage";
565 }
566 protected:
567 explicit FtraceConfig_PrintFilter_Rule_AtraceMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
568 bool is_message_owned = false);
569 public:
570
571 std::string GetTypeName() const final;
572
573 // nested types ----------------------------------------------------
574
575 // accessors -------------------------------------------------------
576
577 enum : int {
578 kTypeFieldNumber = 1,
579 kPrefixFieldNumber = 2,
580 };
581 // optional string type = 1;
582 bool has_type() const;
583 private:
584 bool _internal_has_type() const;
585 public:
586 void clear_type();
587 const std::string& type() const;
588 template <typename ArgT0 = const std::string&, typename... ArgT>
589 void set_type(ArgT0&& arg0, ArgT... args);
590 std::string* mutable_type();
591 PROTOBUF_NODISCARD std::string* release_type();
592 void set_allocated_type(std::string* type);
593 private:
594 const std::string& _internal_type() const;
595 inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
596 std::string* _internal_mutable_type();
597 public:
598
599 // optional string prefix = 2;
600 bool has_prefix() const;
601 private:
602 bool _internal_has_prefix() const;
603 public:
604 void clear_prefix();
605 const std::string& prefix() const;
606 template <typename ArgT0 = const std::string&, typename... ArgT>
607 void set_prefix(ArgT0&& arg0, ArgT... args);
608 std::string* mutable_prefix();
609 PROTOBUF_NODISCARD std::string* release_prefix();
610 void set_allocated_prefix(std::string* prefix);
611 private:
612 const std::string& _internal_prefix() const;
613 inline PROTOBUF_ALWAYS_INLINE void _internal_set_prefix(const std::string& value);
614 std::string* _internal_mutable_prefix();
615 public:
616
617 // @@protoc_insertion_point(class_scope:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage)
618 private:
619 class _Internal;
620
621 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
622 typedef void InternalArenaConstructable_;
623 typedef void DestructorSkippable_;
624 struct Impl_ {
625 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
626 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
627 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
628 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_;
629 };
630 union { Impl_ _impl_; };
631 friend struct ::TableStruct_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto;
632 };
633 // -------------------------------------------------------------------
634
635 class FtraceConfig_PrintFilter_Rule final :
636 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FtraceConfig.PrintFilter.Rule) */ {
637 public:
FtraceConfig_PrintFilter_Rule()638 inline FtraceConfig_PrintFilter_Rule() : FtraceConfig_PrintFilter_Rule(nullptr) {}
639 ~FtraceConfig_PrintFilter_Rule() override;
640 explicit PROTOBUF_CONSTEXPR FtraceConfig_PrintFilter_Rule(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
641
642 FtraceConfig_PrintFilter_Rule(const FtraceConfig_PrintFilter_Rule& from);
FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule && from)643 FtraceConfig_PrintFilter_Rule(FtraceConfig_PrintFilter_Rule&& from) noexcept
644 : FtraceConfig_PrintFilter_Rule() {
645 *this = ::std::move(from);
646 }
647
648 inline FtraceConfig_PrintFilter_Rule& operator=(const FtraceConfig_PrintFilter_Rule& from) {
649 if (this == &from) return *this;
650 CopyFrom(from);
651 return *this;
652 }
653 inline FtraceConfig_PrintFilter_Rule& operator=(FtraceConfig_PrintFilter_Rule&& from) noexcept {
654 if (this == &from) return *this;
655 if (GetOwningArena() == from.GetOwningArena()
656 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
657 && GetOwningArena() != nullptr
658 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
659 ) {
660 InternalSwap(&from);
661 } else {
662 CopyFrom(from);
663 }
664 return *this;
665 }
666
unknown_fields()667 inline const std::string& unknown_fields() const {
668 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
669 }
mutable_unknown_fields()670 inline std::string* mutable_unknown_fields() {
671 return _internal_metadata_.mutable_unknown_fields<std::string>();
672 }
673
default_instance()674 static const FtraceConfig_PrintFilter_Rule& default_instance() {
675 return *internal_default_instance();
676 }
677 enum MatchCase {
678 kPrefix = 1,
679 kAtraceMsg = 3,
680 MATCH_NOT_SET = 0,
681 };
682
internal_default_instance()683 static inline const FtraceConfig_PrintFilter_Rule* internal_default_instance() {
684 return reinterpret_cast<const FtraceConfig_PrintFilter_Rule*>(
685 &_FtraceConfig_PrintFilter_Rule_default_instance_);
686 }
687 static constexpr int kIndexInFileMessages =
688 3;
689
swap(FtraceConfig_PrintFilter_Rule & a,FtraceConfig_PrintFilter_Rule & b)690 friend void swap(FtraceConfig_PrintFilter_Rule& a, FtraceConfig_PrintFilter_Rule& b) {
691 a.Swap(&b);
692 }
Swap(FtraceConfig_PrintFilter_Rule * other)693 inline void Swap(FtraceConfig_PrintFilter_Rule* other) {
694 if (other == this) return;
695 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
696 if (GetOwningArena() != nullptr &&
697 GetOwningArena() == other->GetOwningArena()) {
698 #else // PROTOBUF_FORCE_COPY_IN_SWAP
699 if (GetOwningArena() == other->GetOwningArena()) {
700 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
701 InternalSwap(other);
702 } else {
703 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
704 }
705 }
706 void UnsafeArenaSwap(FtraceConfig_PrintFilter_Rule* other) {
707 if (other == this) return;
708 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
709 InternalSwap(other);
710 }
711
712 // implements Message ----------------------------------------------
713
714 FtraceConfig_PrintFilter_Rule* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
715 return CreateMaybeMessage<FtraceConfig_PrintFilter_Rule>(arena);
716 }
717 FtraceConfig_PrintFilter_Rule* New() const {
718 return New(nullptr);
719 }
720 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
721 void CopyFrom(const FtraceConfig_PrintFilter_Rule& from);
722 void MergeFrom(const FtraceConfig_PrintFilter_Rule& from);
723 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
724 bool IsInitialized() const final;
725
726 size_t ByteSizeLong() const final;
727 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
728 ::uint8_t* _InternalSerialize(
729 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
730 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
731
732 private:
733 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
734 void SharedDtor();
735 void SetCachedSize(int size) const;
736 void InternalSwap(FtraceConfig_PrintFilter_Rule* other);
737
738 private:
739 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
740 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
741 return "perfetto.protos.FtraceConfig.PrintFilter.Rule";
742 }
743 protected:
744 explicit FtraceConfig_PrintFilter_Rule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
745 bool is_message_owned = false);
746 public:
747
748 std::string GetTypeName() const final;
749
750 // nested types ----------------------------------------------------
751
752 typedef FtraceConfig_PrintFilter_Rule_AtraceMessage AtraceMessage;
753
754 // accessors -------------------------------------------------------
755
756 enum : int {
757 kAllowFieldNumber = 2,
758 kPrefixFieldNumber = 1,
759 kAtraceMsgFieldNumber = 3,
760 };
761 // optional bool allow = 2;
762 bool has_allow() const;
763 private:
764 bool _internal_has_allow() const;
765 public:
766 void clear_allow();
767 bool allow() const;
768 void set_allow(bool value);
769 private:
770 bool _internal_allow() const;
771 void _internal_set_allow(bool value);
772 public:
773
774 // string prefix = 1;
775 bool has_prefix() const;
776 private:
777 bool _internal_has_prefix() const;
778 public:
779 void clear_prefix();
780 const std::string& prefix() const;
781 template <typename ArgT0 = const std::string&, typename... ArgT>
782 void set_prefix(ArgT0&& arg0, ArgT... args);
783 std::string* mutable_prefix();
784 PROTOBUF_NODISCARD std::string* release_prefix();
785 void set_allocated_prefix(std::string* prefix);
786 private:
787 const std::string& _internal_prefix() const;
788 inline PROTOBUF_ALWAYS_INLINE void _internal_set_prefix(const std::string& value);
789 std::string* _internal_mutable_prefix();
790 public:
791
792 // .perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage atrace_msg = 3;
793 bool has_atrace_msg() const;
794 private:
795 bool _internal_has_atrace_msg() const;
796 public:
797 void clear_atrace_msg();
798 const ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage& atrace_msg() const;
799 PROTOBUF_NODISCARD ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* release_atrace_msg();
800 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* mutable_atrace_msg();
801 void set_allocated_atrace_msg(::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* atrace_msg);
802 private:
803 const ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage& _internal_atrace_msg() const;
804 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* _internal_mutable_atrace_msg();
805 public:
806 void unsafe_arena_set_allocated_atrace_msg(
807 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* atrace_msg);
808 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* unsafe_arena_release_atrace_msg();
809
810 void clear_match();
811 MatchCase match_case() const;
812 // @@protoc_insertion_point(class_scope:perfetto.protos.FtraceConfig.PrintFilter.Rule)
813 private:
814 class _Internal;
815 void set_has_prefix();
816 void set_has_atrace_msg();
817
818 inline bool has_match() const;
819 inline void clear_has_match();
820
821 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
822 typedef void InternalArenaConstructable_;
823 typedef void DestructorSkippable_;
824 struct Impl_ {
825 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
826 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
827 bool allow_;
828 union MatchUnion {
829 constexpr MatchUnion() : _constinit_{} {}
830 ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
831 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr prefix_;
832 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* atrace_msg_;
833 } match_;
834 ::uint32_t _oneof_case_[1];
835
836 };
837 union { Impl_ _impl_; };
838 friend struct ::TableStruct_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto;
839 };
840 // -------------------------------------------------------------------
841
842 class FtraceConfig_PrintFilter final :
843 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FtraceConfig.PrintFilter) */ {
844 public:
FtraceConfig_PrintFilter()845 inline FtraceConfig_PrintFilter() : FtraceConfig_PrintFilter(nullptr) {}
846 ~FtraceConfig_PrintFilter() override;
847 explicit PROTOBUF_CONSTEXPR FtraceConfig_PrintFilter(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
848
849 FtraceConfig_PrintFilter(const FtraceConfig_PrintFilter& from);
FtraceConfig_PrintFilter(FtraceConfig_PrintFilter && from)850 FtraceConfig_PrintFilter(FtraceConfig_PrintFilter&& from) noexcept
851 : FtraceConfig_PrintFilter() {
852 *this = ::std::move(from);
853 }
854
855 inline FtraceConfig_PrintFilter& operator=(const FtraceConfig_PrintFilter& from) {
856 if (this == &from) return *this;
857 CopyFrom(from);
858 return *this;
859 }
860 inline FtraceConfig_PrintFilter& operator=(FtraceConfig_PrintFilter&& from) noexcept {
861 if (this == &from) return *this;
862 if (GetOwningArena() == from.GetOwningArena()
863 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
864 && GetOwningArena() != nullptr
865 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
866 ) {
867 InternalSwap(&from);
868 } else {
869 CopyFrom(from);
870 }
871 return *this;
872 }
873
unknown_fields()874 inline const std::string& unknown_fields() const {
875 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
876 }
mutable_unknown_fields()877 inline std::string* mutable_unknown_fields() {
878 return _internal_metadata_.mutable_unknown_fields<std::string>();
879 }
880
default_instance()881 static const FtraceConfig_PrintFilter& default_instance() {
882 return *internal_default_instance();
883 }
internal_default_instance()884 static inline const FtraceConfig_PrintFilter* internal_default_instance() {
885 return reinterpret_cast<const FtraceConfig_PrintFilter*>(
886 &_FtraceConfig_PrintFilter_default_instance_);
887 }
888 static constexpr int kIndexInFileMessages =
889 4;
890
swap(FtraceConfig_PrintFilter & a,FtraceConfig_PrintFilter & b)891 friend void swap(FtraceConfig_PrintFilter& a, FtraceConfig_PrintFilter& b) {
892 a.Swap(&b);
893 }
Swap(FtraceConfig_PrintFilter * other)894 inline void Swap(FtraceConfig_PrintFilter* other) {
895 if (other == this) return;
896 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
897 if (GetOwningArena() != nullptr &&
898 GetOwningArena() == other->GetOwningArena()) {
899 #else // PROTOBUF_FORCE_COPY_IN_SWAP
900 if (GetOwningArena() == other->GetOwningArena()) {
901 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
902 InternalSwap(other);
903 } else {
904 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
905 }
906 }
907 void UnsafeArenaSwap(FtraceConfig_PrintFilter* other) {
908 if (other == this) return;
909 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
910 InternalSwap(other);
911 }
912
913 // implements Message ----------------------------------------------
914
915 FtraceConfig_PrintFilter* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
916 return CreateMaybeMessage<FtraceConfig_PrintFilter>(arena);
917 }
918 FtraceConfig_PrintFilter* New() const {
919 return New(nullptr);
920 }
921 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
922 void CopyFrom(const FtraceConfig_PrintFilter& from);
923 void MergeFrom(const FtraceConfig_PrintFilter& from);
924 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
925 bool IsInitialized() const final;
926
927 size_t ByteSizeLong() const final;
928 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
929 ::uint8_t* _InternalSerialize(
930 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
931 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
932
933 private:
934 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
935 void SharedDtor();
936 void SetCachedSize(int size) const;
937 void InternalSwap(FtraceConfig_PrintFilter* other);
938
939 private:
940 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
941 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
942 return "perfetto.protos.FtraceConfig.PrintFilter";
943 }
944 protected:
945 explicit FtraceConfig_PrintFilter(::PROTOBUF_NAMESPACE_ID::Arena* arena,
946 bool is_message_owned = false);
947 public:
948
949 std::string GetTypeName() const final;
950
951 // nested types ----------------------------------------------------
952
953 typedef FtraceConfig_PrintFilter_Rule Rule;
954
955 // accessors -------------------------------------------------------
956
957 enum : int {
958 kRulesFieldNumber = 1,
959 };
960 // repeated .perfetto.protos.FtraceConfig.PrintFilter.Rule rules = 1;
961 int rules_size() const;
962 private:
963 int _internal_rules_size() const;
964 public:
965 void clear_rules();
966 ::perfetto::protos::FtraceConfig_PrintFilter_Rule* mutable_rules(int index);
967 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_PrintFilter_Rule >*
968 mutable_rules();
969 private:
970 const ::perfetto::protos::FtraceConfig_PrintFilter_Rule& _internal_rules(int index) const;
971 ::perfetto::protos::FtraceConfig_PrintFilter_Rule* _internal_add_rules();
972 public:
973 const ::perfetto::protos::FtraceConfig_PrintFilter_Rule& rules(int index) const;
974 ::perfetto::protos::FtraceConfig_PrintFilter_Rule* add_rules();
975 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_PrintFilter_Rule >&
976 rules() const;
977
978 // @@protoc_insertion_point(class_scope:perfetto.protos.FtraceConfig.PrintFilter)
979 private:
980 class _Internal;
981
982 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
983 typedef void InternalArenaConstructable_;
984 typedef void DestructorSkippable_;
985 struct Impl_ {
986 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_PrintFilter_Rule > rules_;
987 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
988 };
989 union { Impl_ _impl_; };
990 friend struct ::TableStruct_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto;
991 };
992 // -------------------------------------------------------------------
993
994 class FtraceConfig final :
995 public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:perfetto.protos.FtraceConfig) */ {
996 public:
FtraceConfig()997 inline FtraceConfig() : FtraceConfig(nullptr) {}
998 ~FtraceConfig() override;
999 explicit PROTOBUF_CONSTEXPR FtraceConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
1000
1001 FtraceConfig(const FtraceConfig& from);
FtraceConfig(FtraceConfig && from)1002 FtraceConfig(FtraceConfig&& from) noexcept
1003 : FtraceConfig() {
1004 *this = ::std::move(from);
1005 }
1006
1007 inline FtraceConfig& operator=(const FtraceConfig& from) {
1008 if (this == &from) return *this;
1009 CopyFrom(from);
1010 return *this;
1011 }
1012 inline FtraceConfig& operator=(FtraceConfig&& from) noexcept {
1013 if (this == &from) return *this;
1014 if (GetOwningArena() == from.GetOwningArena()
1015 #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
1016 && GetOwningArena() != nullptr
1017 #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
1018 ) {
1019 InternalSwap(&from);
1020 } else {
1021 CopyFrom(from);
1022 }
1023 return *this;
1024 }
1025
unknown_fields()1026 inline const std::string& unknown_fields() const {
1027 return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
1028 }
mutable_unknown_fields()1029 inline std::string* mutable_unknown_fields() {
1030 return _internal_metadata_.mutable_unknown_fields<std::string>();
1031 }
1032
default_instance()1033 static const FtraceConfig& default_instance() {
1034 return *internal_default_instance();
1035 }
internal_default_instance()1036 static inline const FtraceConfig* internal_default_instance() {
1037 return reinterpret_cast<const FtraceConfig*>(
1038 &_FtraceConfig_default_instance_);
1039 }
1040 static constexpr int kIndexInFileMessages =
1041 5;
1042
swap(FtraceConfig & a,FtraceConfig & b)1043 friend void swap(FtraceConfig& a, FtraceConfig& b) {
1044 a.Swap(&b);
1045 }
Swap(FtraceConfig * other)1046 inline void Swap(FtraceConfig* other) {
1047 if (other == this) return;
1048 #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
1049 if (GetOwningArena() != nullptr &&
1050 GetOwningArena() == other->GetOwningArena()) {
1051 #else // PROTOBUF_FORCE_COPY_IN_SWAP
1052 if (GetOwningArena() == other->GetOwningArena()) {
1053 #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
1054 InternalSwap(other);
1055 } else {
1056 ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
1057 }
1058 }
1059 void UnsafeArenaSwap(FtraceConfig* other) {
1060 if (other == this) return;
1061 GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
1062 InternalSwap(other);
1063 }
1064
1065 // implements Message ----------------------------------------------
1066
1067 FtraceConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
1068 return CreateMaybeMessage<FtraceConfig>(arena);
1069 }
1070 FtraceConfig* New() const {
1071 return New(nullptr);
1072 }
1073 void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) final;
1074 void CopyFrom(const FtraceConfig& from);
1075 void MergeFrom(const FtraceConfig& from);
1076 PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
1077 bool IsInitialized() const final;
1078
1079 size_t ByteSizeLong() const final;
1080 const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
1081 ::uint8_t* _InternalSerialize(
1082 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1083 int GetCachedSize() const final { return _impl_._cached_size_.Get(); }
1084
1085 private:
1086 void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);
1087 void SharedDtor();
1088 void SetCachedSize(int size) const;
1089 void InternalSwap(FtraceConfig* other);
1090
1091 private:
1092 friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
1093 static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
1094 return "perfetto.protos.FtraceConfig";
1095 }
1096 protected:
1097 explicit FtraceConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1098 bool is_message_owned = false);
1099 public:
1100
1101 std::string GetTypeName() const final;
1102
1103 // nested types ----------------------------------------------------
1104
1105 typedef FtraceConfig_KprobeEvent KprobeEvent;
1106 typedef FtraceConfig_CompactSchedConfig CompactSchedConfig;
1107 typedef FtraceConfig_PrintFilter PrintFilter;
1108
1109 typedef FtraceConfig_KsymsMemPolicy KsymsMemPolicy;
1110 static constexpr KsymsMemPolicy KSYMS_UNSPECIFIED =
1111 FtraceConfig_KsymsMemPolicy_KSYMS_UNSPECIFIED;
1112 static constexpr KsymsMemPolicy KSYMS_CLEANUP_ON_STOP =
1113 FtraceConfig_KsymsMemPolicy_KSYMS_CLEANUP_ON_STOP;
1114 static constexpr KsymsMemPolicy KSYMS_RETAIN =
1115 FtraceConfig_KsymsMemPolicy_KSYMS_RETAIN;
1116 static inline bool KsymsMemPolicy_IsValid(int value) {
1117 return FtraceConfig_KsymsMemPolicy_IsValid(value);
1118 }
1119 static constexpr KsymsMemPolicy KsymsMemPolicy_MIN =
1120 FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_MIN;
1121 static constexpr KsymsMemPolicy KsymsMemPolicy_MAX =
1122 FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_MAX;
1123 static constexpr int KsymsMemPolicy_ARRAYSIZE =
1124 FtraceConfig_KsymsMemPolicy_KsymsMemPolicy_ARRAYSIZE;
1125 template<typename T>
1126 static inline const std::string& KsymsMemPolicy_Name(T enum_t_value) {
1127 static_assert(::std::is_same<T, KsymsMemPolicy>::value ||
1128 ::std::is_integral<T>::value,
1129 "Incorrect type passed to function KsymsMemPolicy_Name.");
1130 return FtraceConfig_KsymsMemPolicy_Name(enum_t_value);
1131 }
1132 static inline bool KsymsMemPolicy_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
1133 KsymsMemPolicy* value) {
1134 return FtraceConfig_KsymsMemPolicy_Parse(name, value);
1135 }
1136
1137 // accessors -------------------------------------------------------
1138
1139 enum : int {
1140 kFtraceEventsFieldNumber = 1,
1141 kAtraceCategoriesFieldNumber = 2,
1142 kAtraceAppsFieldNumber = 3,
1143 kSyscallEventsFieldNumber = 18,
1144 kFunctionFiltersFieldNumber = 20,
1145 kFunctionGraphRootsFieldNumber = 21,
1146 kAtraceCategoriesPreferSdkFieldNumber = 28,
1147 kKprobeEventsFieldNumber = 30,
1148 kInstanceNameFieldNumber = 25,
1149 kCompactSchedFieldNumber = 12,
1150 kPrintFilterFieldNumber = 22,
1151 kBufferSizeKbFieldNumber = 10,
1152 kDrainPeriodMsFieldNumber = 11,
1153 kSymbolizeKsymsFieldNumber = 13,
1154 kInitializeKsymsSynchronouslyForTestingFieldNumber = 14,
1155 kThrottleRssStatFieldNumber = 15,
1156 kDisableGenericEventsFieldNumber = 16,
1157 kKsymsMemPolicyFieldNumber = 17,
1158 kEnableFunctionGraphFieldNumber = 19,
1159 kPreserveFtraceBufferFieldNumber = 23,
1160 kUseMonotonicRawClockFieldNumber = 24,
1161 kBufferSizeLowerBoundFieldNumber = 27,
1162 kDrainBufferPercentFieldNumber = 29,
1163 };
1164 // repeated string ftrace_events = 1;
1165 int ftrace_events_size() const;
1166 private:
1167 int _internal_ftrace_events_size() const;
1168 public:
1169 void clear_ftrace_events();
1170 const std::string& ftrace_events(int index) const;
1171 std::string* mutable_ftrace_events(int index);
1172 void set_ftrace_events(int index, const std::string& value);
1173 void set_ftrace_events(int index, std::string&& value);
1174 void set_ftrace_events(int index, const char* value);
1175 void set_ftrace_events(int index, const char* value, size_t size);
1176 std::string* add_ftrace_events();
1177 void add_ftrace_events(const std::string& value);
1178 void add_ftrace_events(std::string&& value);
1179 void add_ftrace_events(const char* value);
1180 void add_ftrace_events(const char* value, size_t size);
1181 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& ftrace_events() const;
1182 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_ftrace_events();
1183 private:
1184 const std::string& _internal_ftrace_events(int index) const;
1185 std::string* _internal_add_ftrace_events();
1186 public:
1187
1188 // repeated string atrace_categories = 2;
1189 int atrace_categories_size() const;
1190 private:
1191 int _internal_atrace_categories_size() const;
1192 public:
1193 void clear_atrace_categories();
1194 const std::string& atrace_categories(int index) const;
1195 std::string* mutable_atrace_categories(int index);
1196 void set_atrace_categories(int index, const std::string& value);
1197 void set_atrace_categories(int index, std::string&& value);
1198 void set_atrace_categories(int index, const char* value);
1199 void set_atrace_categories(int index, const char* value, size_t size);
1200 std::string* add_atrace_categories();
1201 void add_atrace_categories(const std::string& value);
1202 void add_atrace_categories(std::string&& value);
1203 void add_atrace_categories(const char* value);
1204 void add_atrace_categories(const char* value, size_t size);
1205 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& atrace_categories() const;
1206 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_atrace_categories();
1207 private:
1208 const std::string& _internal_atrace_categories(int index) const;
1209 std::string* _internal_add_atrace_categories();
1210 public:
1211
1212 // repeated string atrace_apps = 3;
1213 int atrace_apps_size() const;
1214 private:
1215 int _internal_atrace_apps_size() const;
1216 public:
1217 void clear_atrace_apps();
1218 const std::string& atrace_apps(int index) const;
1219 std::string* mutable_atrace_apps(int index);
1220 void set_atrace_apps(int index, const std::string& value);
1221 void set_atrace_apps(int index, std::string&& value);
1222 void set_atrace_apps(int index, const char* value);
1223 void set_atrace_apps(int index, const char* value, size_t size);
1224 std::string* add_atrace_apps();
1225 void add_atrace_apps(const std::string& value);
1226 void add_atrace_apps(std::string&& value);
1227 void add_atrace_apps(const char* value);
1228 void add_atrace_apps(const char* value, size_t size);
1229 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& atrace_apps() const;
1230 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_atrace_apps();
1231 private:
1232 const std::string& _internal_atrace_apps(int index) const;
1233 std::string* _internal_add_atrace_apps();
1234 public:
1235
1236 // repeated string syscall_events = 18;
1237 int syscall_events_size() const;
1238 private:
1239 int _internal_syscall_events_size() const;
1240 public:
1241 void clear_syscall_events();
1242 const std::string& syscall_events(int index) const;
1243 std::string* mutable_syscall_events(int index);
1244 void set_syscall_events(int index, const std::string& value);
1245 void set_syscall_events(int index, std::string&& value);
1246 void set_syscall_events(int index, const char* value);
1247 void set_syscall_events(int index, const char* value, size_t size);
1248 std::string* add_syscall_events();
1249 void add_syscall_events(const std::string& value);
1250 void add_syscall_events(std::string&& value);
1251 void add_syscall_events(const char* value);
1252 void add_syscall_events(const char* value, size_t size);
1253 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& syscall_events() const;
1254 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_syscall_events();
1255 private:
1256 const std::string& _internal_syscall_events(int index) const;
1257 std::string* _internal_add_syscall_events();
1258 public:
1259
1260 // repeated string function_filters = 20;
1261 int function_filters_size() const;
1262 private:
1263 int _internal_function_filters_size() const;
1264 public:
1265 void clear_function_filters();
1266 const std::string& function_filters(int index) const;
1267 std::string* mutable_function_filters(int index);
1268 void set_function_filters(int index, const std::string& value);
1269 void set_function_filters(int index, std::string&& value);
1270 void set_function_filters(int index, const char* value);
1271 void set_function_filters(int index, const char* value, size_t size);
1272 std::string* add_function_filters();
1273 void add_function_filters(const std::string& value);
1274 void add_function_filters(std::string&& value);
1275 void add_function_filters(const char* value);
1276 void add_function_filters(const char* value, size_t size);
1277 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& function_filters() const;
1278 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_function_filters();
1279 private:
1280 const std::string& _internal_function_filters(int index) const;
1281 std::string* _internal_add_function_filters();
1282 public:
1283
1284 // repeated string function_graph_roots = 21;
1285 int function_graph_roots_size() const;
1286 private:
1287 int _internal_function_graph_roots_size() const;
1288 public:
1289 void clear_function_graph_roots();
1290 const std::string& function_graph_roots(int index) const;
1291 std::string* mutable_function_graph_roots(int index);
1292 void set_function_graph_roots(int index, const std::string& value);
1293 void set_function_graph_roots(int index, std::string&& value);
1294 void set_function_graph_roots(int index, const char* value);
1295 void set_function_graph_roots(int index, const char* value, size_t size);
1296 std::string* add_function_graph_roots();
1297 void add_function_graph_roots(const std::string& value);
1298 void add_function_graph_roots(std::string&& value);
1299 void add_function_graph_roots(const char* value);
1300 void add_function_graph_roots(const char* value, size_t size);
1301 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& function_graph_roots() const;
1302 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_function_graph_roots();
1303 private:
1304 const std::string& _internal_function_graph_roots(int index) const;
1305 std::string* _internal_add_function_graph_roots();
1306 public:
1307
1308 // repeated string atrace_categories_prefer_sdk = 28;
1309 int atrace_categories_prefer_sdk_size() const;
1310 private:
1311 int _internal_atrace_categories_prefer_sdk_size() const;
1312 public:
1313 void clear_atrace_categories_prefer_sdk();
1314 const std::string& atrace_categories_prefer_sdk(int index) const;
1315 std::string* mutable_atrace_categories_prefer_sdk(int index);
1316 void set_atrace_categories_prefer_sdk(int index, const std::string& value);
1317 void set_atrace_categories_prefer_sdk(int index, std::string&& value);
1318 void set_atrace_categories_prefer_sdk(int index, const char* value);
1319 void set_atrace_categories_prefer_sdk(int index, const char* value, size_t size);
1320 std::string* add_atrace_categories_prefer_sdk();
1321 void add_atrace_categories_prefer_sdk(const std::string& value);
1322 void add_atrace_categories_prefer_sdk(std::string&& value);
1323 void add_atrace_categories_prefer_sdk(const char* value);
1324 void add_atrace_categories_prefer_sdk(const char* value, size_t size);
1325 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& atrace_categories_prefer_sdk() const;
1326 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_atrace_categories_prefer_sdk();
1327 private:
1328 const std::string& _internal_atrace_categories_prefer_sdk(int index) const;
1329 std::string* _internal_add_atrace_categories_prefer_sdk();
1330 public:
1331
1332 // repeated .perfetto.protos.FtraceConfig.KprobeEvent kprobe_events = 30;
1333 int kprobe_events_size() const;
1334 private:
1335 int _internal_kprobe_events_size() const;
1336 public:
1337 void clear_kprobe_events();
1338 ::perfetto::protos::FtraceConfig_KprobeEvent* mutable_kprobe_events(int index);
1339 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_KprobeEvent >*
1340 mutable_kprobe_events();
1341 private:
1342 const ::perfetto::protos::FtraceConfig_KprobeEvent& _internal_kprobe_events(int index) const;
1343 ::perfetto::protos::FtraceConfig_KprobeEvent* _internal_add_kprobe_events();
1344 public:
1345 const ::perfetto::protos::FtraceConfig_KprobeEvent& kprobe_events(int index) const;
1346 ::perfetto::protos::FtraceConfig_KprobeEvent* add_kprobe_events();
1347 const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_KprobeEvent >&
1348 kprobe_events() const;
1349
1350 // optional string instance_name = 25;
1351 bool has_instance_name() const;
1352 private:
1353 bool _internal_has_instance_name() const;
1354 public:
1355 void clear_instance_name();
1356 const std::string& instance_name() const;
1357 template <typename ArgT0 = const std::string&, typename... ArgT>
1358 void set_instance_name(ArgT0&& arg0, ArgT... args);
1359 std::string* mutable_instance_name();
1360 PROTOBUF_NODISCARD std::string* release_instance_name();
1361 void set_allocated_instance_name(std::string* instance_name);
1362 private:
1363 const std::string& _internal_instance_name() const;
1364 inline PROTOBUF_ALWAYS_INLINE void _internal_set_instance_name(const std::string& value);
1365 std::string* _internal_mutable_instance_name();
1366 public:
1367
1368 // optional .perfetto.protos.FtraceConfig.CompactSchedConfig compact_sched = 12;
1369 bool has_compact_sched() const;
1370 private:
1371 bool _internal_has_compact_sched() const;
1372 public:
1373 void clear_compact_sched();
1374 const ::perfetto::protos::FtraceConfig_CompactSchedConfig& compact_sched() const;
1375 PROTOBUF_NODISCARD ::perfetto::protos::FtraceConfig_CompactSchedConfig* release_compact_sched();
1376 ::perfetto::protos::FtraceConfig_CompactSchedConfig* mutable_compact_sched();
1377 void set_allocated_compact_sched(::perfetto::protos::FtraceConfig_CompactSchedConfig* compact_sched);
1378 private:
1379 const ::perfetto::protos::FtraceConfig_CompactSchedConfig& _internal_compact_sched() const;
1380 ::perfetto::protos::FtraceConfig_CompactSchedConfig* _internal_mutable_compact_sched();
1381 public:
1382 void unsafe_arena_set_allocated_compact_sched(
1383 ::perfetto::protos::FtraceConfig_CompactSchedConfig* compact_sched);
1384 ::perfetto::protos::FtraceConfig_CompactSchedConfig* unsafe_arena_release_compact_sched();
1385
1386 // optional .perfetto.protos.FtraceConfig.PrintFilter print_filter = 22;
1387 bool has_print_filter() const;
1388 private:
1389 bool _internal_has_print_filter() const;
1390 public:
1391 void clear_print_filter();
1392 const ::perfetto::protos::FtraceConfig_PrintFilter& print_filter() const;
1393 PROTOBUF_NODISCARD ::perfetto::protos::FtraceConfig_PrintFilter* release_print_filter();
1394 ::perfetto::protos::FtraceConfig_PrintFilter* mutable_print_filter();
1395 void set_allocated_print_filter(::perfetto::protos::FtraceConfig_PrintFilter* print_filter);
1396 private:
1397 const ::perfetto::protos::FtraceConfig_PrintFilter& _internal_print_filter() const;
1398 ::perfetto::protos::FtraceConfig_PrintFilter* _internal_mutable_print_filter();
1399 public:
1400 void unsafe_arena_set_allocated_print_filter(
1401 ::perfetto::protos::FtraceConfig_PrintFilter* print_filter);
1402 ::perfetto::protos::FtraceConfig_PrintFilter* unsafe_arena_release_print_filter();
1403
1404 // optional uint32 buffer_size_kb = 10;
1405 bool has_buffer_size_kb() const;
1406 private:
1407 bool _internal_has_buffer_size_kb() const;
1408 public:
1409 void clear_buffer_size_kb();
1410 ::uint32_t buffer_size_kb() const;
1411 void set_buffer_size_kb(::uint32_t value);
1412 private:
1413 ::uint32_t _internal_buffer_size_kb() const;
1414 void _internal_set_buffer_size_kb(::uint32_t value);
1415 public:
1416
1417 // optional uint32 drain_period_ms = 11;
1418 bool has_drain_period_ms() const;
1419 private:
1420 bool _internal_has_drain_period_ms() const;
1421 public:
1422 void clear_drain_period_ms();
1423 ::uint32_t drain_period_ms() const;
1424 void set_drain_period_ms(::uint32_t value);
1425 private:
1426 ::uint32_t _internal_drain_period_ms() const;
1427 void _internal_set_drain_period_ms(::uint32_t value);
1428 public:
1429
1430 // optional bool symbolize_ksyms = 13;
1431 bool has_symbolize_ksyms() const;
1432 private:
1433 bool _internal_has_symbolize_ksyms() const;
1434 public:
1435 void clear_symbolize_ksyms();
1436 bool symbolize_ksyms() const;
1437 void set_symbolize_ksyms(bool value);
1438 private:
1439 bool _internal_symbolize_ksyms() const;
1440 void _internal_set_symbolize_ksyms(bool value);
1441 public:
1442
1443 // optional bool initialize_ksyms_synchronously_for_testing = 14 [deprecated = true];
1444 PROTOBUF_DEPRECATED bool has_initialize_ksyms_synchronously_for_testing() const;
1445 private:
1446 bool _internal_has_initialize_ksyms_synchronously_for_testing() const;
1447 public:
1448 PROTOBUF_DEPRECATED void clear_initialize_ksyms_synchronously_for_testing();
1449 PROTOBUF_DEPRECATED bool initialize_ksyms_synchronously_for_testing() const;
1450 PROTOBUF_DEPRECATED void set_initialize_ksyms_synchronously_for_testing(bool value);
1451 private:
1452 bool _internal_initialize_ksyms_synchronously_for_testing() const;
1453 void _internal_set_initialize_ksyms_synchronously_for_testing(bool value);
1454 public:
1455
1456 // optional bool throttle_rss_stat = 15;
1457 bool has_throttle_rss_stat() const;
1458 private:
1459 bool _internal_has_throttle_rss_stat() const;
1460 public:
1461 void clear_throttle_rss_stat();
1462 bool throttle_rss_stat() const;
1463 void set_throttle_rss_stat(bool value);
1464 private:
1465 bool _internal_throttle_rss_stat() const;
1466 void _internal_set_throttle_rss_stat(bool value);
1467 public:
1468
1469 // optional bool disable_generic_events = 16;
1470 bool has_disable_generic_events() const;
1471 private:
1472 bool _internal_has_disable_generic_events() const;
1473 public:
1474 void clear_disable_generic_events();
1475 bool disable_generic_events() const;
1476 void set_disable_generic_events(bool value);
1477 private:
1478 bool _internal_disable_generic_events() const;
1479 void _internal_set_disable_generic_events(bool value);
1480 public:
1481
1482 // optional .perfetto.protos.FtraceConfig.KsymsMemPolicy ksyms_mem_policy = 17;
1483 bool has_ksyms_mem_policy() const;
1484 private:
1485 bool _internal_has_ksyms_mem_policy() const;
1486 public:
1487 void clear_ksyms_mem_policy();
1488 ::perfetto::protos::FtraceConfig_KsymsMemPolicy ksyms_mem_policy() const;
1489 void set_ksyms_mem_policy(::perfetto::protos::FtraceConfig_KsymsMemPolicy value);
1490 private:
1491 ::perfetto::protos::FtraceConfig_KsymsMemPolicy _internal_ksyms_mem_policy() const;
1492 void _internal_set_ksyms_mem_policy(::perfetto::protos::FtraceConfig_KsymsMemPolicy value);
1493 public:
1494
1495 // optional bool enable_function_graph = 19;
1496 bool has_enable_function_graph() const;
1497 private:
1498 bool _internal_has_enable_function_graph() const;
1499 public:
1500 void clear_enable_function_graph();
1501 bool enable_function_graph() const;
1502 void set_enable_function_graph(bool value);
1503 private:
1504 bool _internal_enable_function_graph() const;
1505 void _internal_set_enable_function_graph(bool value);
1506 public:
1507
1508 // optional bool preserve_ftrace_buffer = 23;
1509 bool has_preserve_ftrace_buffer() const;
1510 private:
1511 bool _internal_has_preserve_ftrace_buffer() const;
1512 public:
1513 void clear_preserve_ftrace_buffer();
1514 bool preserve_ftrace_buffer() const;
1515 void set_preserve_ftrace_buffer(bool value);
1516 private:
1517 bool _internal_preserve_ftrace_buffer() const;
1518 void _internal_set_preserve_ftrace_buffer(bool value);
1519 public:
1520
1521 // optional bool use_monotonic_raw_clock = 24;
1522 bool has_use_monotonic_raw_clock() const;
1523 private:
1524 bool _internal_has_use_monotonic_raw_clock() const;
1525 public:
1526 void clear_use_monotonic_raw_clock();
1527 bool use_monotonic_raw_clock() const;
1528 void set_use_monotonic_raw_clock(bool value);
1529 private:
1530 bool _internal_use_monotonic_raw_clock() const;
1531 void _internal_set_use_monotonic_raw_clock(bool value);
1532 public:
1533
1534 // optional bool buffer_size_lower_bound = 27;
1535 bool has_buffer_size_lower_bound() const;
1536 private:
1537 bool _internal_has_buffer_size_lower_bound() const;
1538 public:
1539 void clear_buffer_size_lower_bound();
1540 bool buffer_size_lower_bound() const;
1541 void set_buffer_size_lower_bound(bool value);
1542 private:
1543 bool _internal_buffer_size_lower_bound() const;
1544 void _internal_set_buffer_size_lower_bound(bool value);
1545 public:
1546
1547 // optional uint32 drain_buffer_percent = 29;
1548 bool has_drain_buffer_percent() const;
1549 private:
1550 bool _internal_has_drain_buffer_percent() const;
1551 public:
1552 void clear_drain_buffer_percent();
1553 ::uint32_t drain_buffer_percent() const;
1554 void set_drain_buffer_percent(::uint32_t value);
1555 private:
1556 ::uint32_t _internal_drain_buffer_percent() const;
1557 void _internal_set_drain_buffer_percent(::uint32_t value);
1558 public:
1559
1560 // @@protoc_insertion_point(class_scope:perfetto.protos.FtraceConfig)
1561 private:
1562 class _Internal;
1563
1564 template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
1565 typedef void InternalArenaConstructable_;
1566 typedef void DestructorSkippable_;
1567 struct Impl_ {
1568 ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
1569 mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
1570 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> ftrace_events_;
1571 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> atrace_categories_;
1572 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> atrace_apps_;
1573 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> syscall_events_;
1574 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> function_filters_;
1575 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> function_graph_roots_;
1576 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> atrace_categories_prefer_sdk_;
1577 ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_KprobeEvent > kprobe_events_;
1578 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr instance_name_;
1579 ::perfetto::protos::FtraceConfig_CompactSchedConfig* compact_sched_;
1580 ::perfetto::protos::FtraceConfig_PrintFilter* print_filter_;
1581 ::uint32_t buffer_size_kb_;
1582 ::uint32_t drain_period_ms_;
1583 bool symbolize_ksyms_;
1584 bool initialize_ksyms_synchronously_for_testing_;
1585 bool throttle_rss_stat_;
1586 bool disable_generic_events_;
1587 int ksyms_mem_policy_;
1588 bool enable_function_graph_;
1589 bool preserve_ftrace_buffer_;
1590 bool use_monotonic_raw_clock_;
1591 bool buffer_size_lower_bound_;
1592 ::uint32_t drain_buffer_percent_;
1593 };
1594 union { Impl_ _impl_; };
1595 friend struct ::TableStruct_protos_2fperfetto_2fconfig_2fftrace_2fftrace_5fconfig_2eproto;
1596 };
1597 // ===================================================================
1598
1599
1600 // ===================================================================
1601
1602 #ifdef __GNUC__
1603 #pragma GCC diagnostic push
1604 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1605 #endif // __GNUC__
1606 // FtraceConfig_KprobeEvent
1607
1608 // optional string probe = 1;
_internal_has_probe()1609 inline bool FtraceConfig_KprobeEvent::_internal_has_probe() const {
1610 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1611 return value;
1612 }
has_probe()1613 inline bool FtraceConfig_KprobeEvent::has_probe() const {
1614 return _internal_has_probe();
1615 }
clear_probe()1616 inline void FtraceConfig_KprobeEvent::clear_probe() {
1617 _impl_.probe_.ClearToEmpty();
1618 _impl_._has_bits_[0] &= ~0x00000001u;
1619 }
probe()1620 inline const std::string& FtraceConfig_KprobeEvent::probe() const {
1621 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.KprobeEvent.probe)
1622 return _internal_probe();
1623 }
1624 template <typename ArgT0, typename... ArgT>
1625 inline PROTOBUF_ALWAYS_INLINE
set_probe(ArgT0 && arg0,ArgT...args)1626 void FtraceConfig_KprobeEvent::set_probe(ArgT0&& arg0, ArgT... args) {
1627 _impl_._has_bits_[0] |= 0x00000001u;
1628 _impl_.probe_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1629 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.KprobeEvent.probe)
1630 }
mutable_probe()1631 inline std::string* FtraceConfig_KprobeEvent::mutable_probe() {
1632 std::string* _s = _internal_mutable_probe();
1633 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.KprobeEvent.probe)
1634 return _s;
1635 }
_internal_probe()1636 inline const std::string& FtraceConfig_KprobeEvent::_internal_probe() const {
1637 return _impl_.probe_.Get();
1638 }
_internal_set_probe(const std::string & value)1639 inline void FtraceConfig_KprobeEvent::_internal_set_probe(const std::string& value) {
1640 _impl_._has_bits_[0] |= 0x00000001u;
1641 _impl_.probe_.Set(value, GetArenaForAllocation());
1642 }
_internal_mutable_probe()1643 inline std::string* FtraceConfig_KprobeEvent::_internal_mutable_probe() {
1644 _impl_._has_bits_[0] |= 0x00000001u;
1645 return _impl_.probe_.Mutable(GetArenaForAllocation());
1646 }
release_probe()1647 inline std::string* FtraceConfig_KprobeEvent::release_probe() {
1648 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.KprobeEvent.probe)
1649 if (!_internal_has_probe()) {
1650 return nullptr;
1651 }
1652 _impl_._has_bits_[0] &= ~0x00000001u;
1653 auto* p = _impl_.probe_.Release();
1654 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1655 if (_impl_.probe_.IsDefault()) {
1656 _impl_.probe_.Set("", GetArenaForAllocation());
1657 }
1658 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1659 return p;
1660 }
set_allocated_probe(std::string * probe)1661 inline void FtraceConfig_KprobeEvent::set_allocated_probe(std::string* probe) {
1662 if (probe != nullptr) {
1663 _impl_._has_bits_[0] |= 0x00000001u;
1664 } else {
1665 _impl_._has_bits_[0] &= ~0x00000001u;
1666 }
1667 _impl_.probe_.SetAllocated(probe, GetArenaForAllocation());
1668 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1669 if (_impl_.probe_.IsDefault()) {
1670 _impl_.probe_.Set("", GetArenaForAllocation());
1671 }
1672 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1673 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FtraceConfig.KprobeEvent.probe)
1674 }
1675
1676 // optional .perfetto.protos.FtraceConfig.KprobeEvent.KprobeType type = 2;
_internal_has_type()1677 inline bool FtraceConfig_KprobeEvent::_internal_has_type() const {
1678 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1679 return value;
1680 }
has_type()1681 inline bool FtraceConfig_KprobeEvent::has_type() const {
1682 return _internal_has_type();
1683 }
clear_type()1684 inline void FtraceConfig_KprobeEvent::clear_type() {
1685 _impl_.type_ = 0;
1686 _impl_._has_bits_[0] &= ~0x00000002u;
1687 }
_internal_type()1688 inline ::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType FtraceConfig_KprobeEvent::_internal_type() const {
1689 return static_cast< ::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType >(_impl_.type_);
1690 }
type()1691 inline ::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType FtraceConfig_KprobeEvent::type() const {
1692 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.KprobeEvent.type)
1693 return _internal_type();
1694 }
_internal_set_type(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType value)1695 inline void FtraceConfig_KprobeEvent::_internal_set_type(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType value) {
1696 assert(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType_IsValid(value));
1697 _impl_._has_bits_[0] |= 0x00000002u;
1698 _impl_.type_ = value;
1699 }
set_type(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType value)1700 inline void FtraceConfig_KprobeEvent::set_type(::perfetto::protos::FtraceConfig_KprobeEvent_KprobeType value) {
1701 _internal_set_type(value);
1702 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.KprobeEvent.type)
1703 }
1704
1705 // -------------------------------------------------------------------
1706
1707 // FtraceConfig_CompactSchedConfig
1708
1709 // optional bool enabled = 1;
_internal_has_enabled()1710 inline bool FtraceConfig_CompactSchedConfig::_internal_has_enabled() const {
1711 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1712 return value;
1713 }
has_enabled()1714 inline bool FtraceConfig_CompactSchedConfig::has_enabled() const {
1715 return _internal_has_enabled();
1716 }
clear_enabled()1717 inline void FtraceConfig_CompactSchedConfig::clear_enabled() {
1718 _impl_.enabled_ = false;
1719 _impl_._has_bits_[0] &= ~0x00000001u;
1720 }
_internal_enabled()1721 inline bool FtraceConfig_CompactSchedConfig::_internal_enabled() const {
1722 return _impl_.enabled_;
1723 }
enabled()1724 inline bool FtraceConfig_CompactSchedConfig::enabled() const {
1725 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.CompactSchedConfig.enabled)
1726 return _internal_enabled();
1727 }
_internal_set_enabled(bool value)1728 inline void FtraceConfig_CompactSchedConfig::_internal_set_enabled(bool value) {
1729 _impl_._has_bits_[0] |= 0x00000001u;
1730 _impl_.enabled_ = value;
1731 }
set_enabled(bool value)1732 inline void FtraceConfig_CompactSchedConfig::set_enabled(bool value) {
1733 _internal_set_enabled(value);
1734 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.CompactSchedConfig.enabled)
1735 }
1736
1737 // -------------------------------------------------------------------
1738
1739 // FtraceConfig_PrintFilter_Rule_AtraceMessage
1740
1741 // optional string type = 1;
_internal_has_type()1742 inline bool FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_has_type() const {
1743 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
1744 return value;
1745 }
has_type()1746 inline bool FtraceConfig_PrintFilter_Rule_AtraceMessage::has_type() const {
1747 return _internal_has_type();
1748 }
clear_type()1749 inline void FtraceConfig_PrintFilter_Rule_AtraceMessage::clear_type() {
1750 _impl_.type_.ClearToEmpty();
1751 _impl_._has_bits_[0] &= ~0x00000001u;
1752 }
type()1753 inline const std::string& FtraceConfig_PrintFilter_Rule_AtraceMessage::type() const {
1754 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.type)
1755 return _internal_type();
1756 }
1757 template <typename ArgT0, typename... ArgT>
1758 inline PROTOBUF_ALWAYS_INLINE
set_type(ArgT0 && arg0,ArgT...args)1759 void FtraceConfig_PrintFilter_Rule_AtraceMessage::set_type(ArgT0&& arg0, ArgT... args) {
1760 _impl_._has_bits_[0] |= 0x00000001u;
1761 _impl_.type_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1762 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.type)
1763 }
mutable_type()1764 inline std::string* FtraceConfig_PrintFilter_Rule_AtraceMessage::mutable_type() {
1765 std::string* _s = _internal_mutable_type();
1766 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.type)
1767 return _s;
1768 }
_internal_type()1769 inline const std::string& FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_type() const {
1770 return _impl_.type_.Get();
1771 }
_internal_set_type(const std::string & value)1772 inline void FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_set_type(const std::string& value) {
1773 _impl_._has_bits_[0] |= 0x00000001u;
1774 _impl_.type_.Set(value, GetArenaForAllocation());
1775 }
_internal_mutable_type()1776 inline std::string* FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_mutable_type() {
1777 _impl_._has_bits_[0] |= 0x00000001u;
1778 return _impl_.type_.Mutable(GetArenaForAllocation());
1779 }
release_type()1780 inline std::string* FtraceConfig_PrintFilter_Rule_AtraceMessage::release_type() {
1781 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.type)
1782 if (!_internal_has_type()) {
1783 return nullptr;
1784 }
1785 _impl_._has_bits_[0] &= ~0x00000001u;
1786 auto* p = _impl_.type_.Release();
1787 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1788 if (_impl_.type_.IsDefault()) {
1789 _impl_.type_.Set("", GetArenaForAllocation());
1790 }
1791 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1792 return p;
1793 }
set_allocated_type(std::string * type)1794 inline void FtraceConfig_PrintFilter_Rule_AtraceMessage::set_allocated_type(std::string* type) {
1795 if (type != nullptr) {
1796 _impl_._has_bits_[0] |= 0x00000001u;
1797 } else {
1798 _impl_._has_bits_[0] &= ~0x00000001u;
1799 }
1800 _impl_.type_.SetAllocated(type, GetArenaForAllocation());
1801 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1802 if (_impl_.type_.IsDefault()) {
1803 _impl_.type_.Set("", GetArenaForAllocation());
1804 }
1805 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1806 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.type)
1807 }
1808
1809 // optional string prefix = 2;
_internal_has_prefix()1810 inline bool FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_has_prefix() const {
1811 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
1812 return value;
1813 }
has_prefix()1814 inline bool FtraceConfig_PrintFilter_Rule_AtraceMessage::has_prefix() const {
1815 return _internal_has_prefix();
1816 }
clear_prefix()1817 inline void FtraceConfig_PrintFilter_Rule_AtraceMessage::clear_prefix() {
1818 _impl_.prefix_.ClearToEmpty();
1819 _impl_._has_bits_[0] &= ~0x00000002u;
1820 }
prefix()1821 inline const std::string& FtraceConfig_PrintFilter_Rule_AtraceMessage::prefix() const {
1822 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.prefix)
1823 return _internal_prefix();
1824 }
1825 template <typename ArgT0, typename... ArgT>
1826 inline PROTOBUF_ALWAYS_INLINE
set_prefix(ArgT0 && arg0,ArgT...args)1827 void FtraceConfig_PrintFilter_Rule_AtraceMessage::set_prefix(ArgT0&& arg0, ArgT... args) {
1828 _impl_._has_bits_[0] |= 0x00000002u;
1829 _impl_.prefix_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1830 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.prefix)
1831 }
mutable_prefix()1832 inline std::string* FtraceConfig_PrintFilter_Rule_AtraceMessage::mutable_prefix() {
1833 std::string* _s = _internal_mutable_prefix();
1834 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.prefix)
1835 return _s;
1836 }
_internal_prefix()1837 inline const std::string& FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_prefix() const {
1838 return _impl_.prefix_.Get();
1839 }
_internal_set_prefix(const std::string & value)1840 inline void FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_set_prefix(const std::string& value) {
1841 _impl_._has_bits_[0] |= 0x00000002u;
1842 _impl_.prefix_.Set(value, GetArenaForAllocation());
1843 }
_internal_mutable_prefix()1844 inline std::string* FtraceConfig_PrintFilter_Rule_AtraceMessage::_internal_mutable_prefix() {
1845 _impl_._has_bits_[0] |= 0x00000002u;
1846 return _impl_.prefix_.Mutable(GetArenaForAllocation());
1847 }
release_prefix()1848 inline std::string* FtraceConfig_PrintFilter_Rule_AtraceMessage::release_prefix() {
1849 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.prefix)
1850 if (!_internal_has_prefix()) {
1851 return nullptr;
1852 }
1853 _impl_._has_bits_[0] &= ~0x00000002u;
1854 auto* p = _impl_.prefix_.Release();
1855 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1856 if (_impl_.prefix_.IsDefault()) {
1857 _impl_.prefix_.Set("", GetArenaForAllocation());
1858 }
1859 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1860 return p;
1861 }
set_allocated_prefix(std::string * prefix)1862 inline void FtraceConfig_PrintFilter_Rule_AtraceMessage::set_allocated_prefix(std::string* prefix) {
1863 if (prefix != nullptr) {
1864 _impl_._has_bits_[0] |= 0x00000002u;
1865 } else {
1866 _impl_._has_bits_[0] &= ~0x00000002u;
1867 }
1868 _impl_.prefix_.SetAllocated(prefix, GetArenaForAllocation());
1869 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1870 if (_impl_.prefix_.IsDefault()) {
1871 _impl_.prefix_.Set("", GetArenaForAllocation());
1872 }
1873 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1874 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage.prefix)
1875 }
1876
1877 // -------------------------------------------------------------------
1878
1879 // FtraceConfig_PrintFilter_Rule
1880
1881 // string prefix = 1;
_internal_has_prefix()1882 inline bool FtraceConfig_PrintFilter_Rule::_internal_has_prefix() const {
1883 return match_case() == kPrefix;
1884 }
has_prefix()1885 inline bool FtraceConfig_PrintFilter_Rule::has_prefix() const {
1886 return _internal_has_prefix();
1887 }
set_has_prefix()1888 inline void FtraceConfig_PrintFilter_Rule::set_has_prefix() {
1889 _impl_._oneof_case_[0] = kPrefix;
1890 }
clear_prefix()1891 inline void FtraceConfig_PrintFilter_Rule::clear_prefix() {
1892 if (_internal_has_prefix()) {
1893 _impl_.match_.prefix_.Destroy();
1894 clear_has_match();
1895 }
1896 }
prefix()1897 inline const std::string& FtraceConfig_PrintFilter_Rule::prefix() const {
1898 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.PrintFilter.Rule.prefix)
1899 return _internal_prefix();
1900 }
1901 template <typename ArgT0, typename... ArgT>
set_prefix(ArgT0 && arg0,ArgT...args)1902 inline void FtraceConfig_PrintFilter_Rule::set_prefix(ArgT0&& arg0, ArgT... args) {
1903 if (!_internal_has_prefix()) {
1904 clear_match();
1905 set_has_prefix();
1906 _impl_.match_.prefix_.InitDefault();
1907 }
1908 _impl_.match_.prefix_.Set( static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
1909 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.PrintFilter.Rule.prefix)
1910 }
mutable_prefix()1911 inline std::string* FtraceConfig_PrintFilter_Rule::mutable_prefix() {
1912 std::string* _s = _internal_mutable_prefix();
1913 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.PrintFilter.Rule.prefix)
1914 return _s;
1915 }
_internal_prefix()1916 inline const std::string& FtraceConfig_PrintFilter_Rule::_internal_prefix() const {
1917 if (_internal_has_prefix()) {
1918 return _impl_.match_.prefix_.Get();
1919 }
1920 return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
1921 }
_internal_set_prefix(const std::string & value)1922 inline void FtraceConfig_PrintFilter_Rule::_internal_set_prefix(const std::string& value) {
1923 if (!_internal_has_prefix()) {
1924 clear_match();
1925 set_has_prefix();
1926 _impl_.match_.prefix_.InitDefault();
1927 }
1928 _impl_.match_.prefix_.Set(value, GetArenaForAllocation());
1929 }
_internal_mutable_prefix()1930 inline std::string* FtraceConfig_PrintFilter_Rule::_internal_mutable_prefix() {
1931 if (!_internal_has_prefix()) {
1932 clear_match();
1933 set_has_prefix();
1934 _impl_.match_.prefix_.InitDefault();
1935 }
1936 return _impl_.match_.prefix_.Mutable( GetArenaForAllocation());
1937 }
release_prefix()1938 inline std::string* FtraceConfig_PrintFilter_Rule::release_prefix() {
1939 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.PrintFilter.Rule.prefix)
1940 if (_internal_has_prefix()) {
1941 clear_has_match();
1942 return _impl_.match_.prefix_.Release();
1943 } else {
1944 return nullptr;
1945 }
1946 }
set_allocated_prefix(std::string * prefix)1947 inline void FtraceConfig_PrintFilter_Rule::set_allocated_prefix(std::string* prefix) {
1948 if (has_match()) {
1949 clear_match();
1950 }
1951 if (prefix != nullptr) {
1952 set_has_prefix();
1953 _impl_.match_.prefix_.InitAllocated(prefix, GetArenaForAllocation());
1954 }
1955 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FtraceConfig.PrintFilter.Rule.prefix)
1956 }
1957
1958 // .perfetto.protos.FtraceConfig.PrintFilter.Rule.AtraceMessage atrace_msg = 3;
_internal_has_atrace_msg()1959 inline bool FtraceConfig_PrintFilter_Rule::_internal_has_atrace_msg() const {
1960 return match_case() == kAtraceMsg;
1961 }
has_atrace_msg()1962 inline bool FtraceConfig_PrintFilter_Rule::has_atrace_msg() const {
1963 return _internal_has_atrace_msg();
1964 }
set_has_atrace_msg()1965 inline void FtraceConfig_PrintFilter_Rule::set_has_atrace_msg() {
1966 _impl_._oneof_case_[0] = kAtraceMsg;
1967 }
clear_atrace_msg()1968 inline void FtraceConfig_PrintFilter_Rule::clear_atrace_msg() {
1969 if (_internal_has_atrace_msg()) {
1970 if (GetArenaForAllocation() == nullptr) {
1971 delete _impl_.match_.atrace_msg_;
1972 }
1973 clear_has_match();
1974 }
1975 }
release_atrace_msg()1976 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* FtraceConfig_PrintFilter_Rule::release_atrace_msg() {
1977 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.PrintFilter.Rule.atrace_msg)
1978 if (_internal_has_atrace_msg()) {
1979 clear_has_match();
1980 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* temp = _impl_.match_.atrace_msg_;
1981 if (GetArenaForAllocation() != nullptr) {
1982 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
1983 }
1984 _impl_.match_.atrace_msg_ = nullptr;
1985 return temp;
1986 } else {
1987 return nullptr;
1988 }
1989 }
_internal_atrace_msg()1990 inline const ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage& FtraceConfig_PrintFilter_Rule::_internal_atrace_msg() const {
1991 return _internal_has_atrace_msg()
1992 ? *_impl_.match_.atrace_msg_
1993 : reinterpret_cast< ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage&>(::perfetto::protos::_FtraceConfig_PrintFilter_Rule_AtraceMessage_default_instance_);
1994 }
atrace_msg()1995 inline const ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage& FtraceConfig_PrintFilter_Rule::atrace_msg() const {
1996 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.PrintFilter.Rule.atrace_msg)
1997 return _internal_atrace_msg();
1998 }
unsafe_arena_release_atrace_msg()1999 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* FtraceConfig_PrintFilter_Rule::unsafe_arena_release_atrace_msg() {
2000 // @@protoc_insertion_point(field_unsafe_arena_release:perfetto.protos.FtraceConfig.PrintFilter.Rule.atrace_msg)
2001 if (_internal_has_atrace_msg()) {
2002 clear_has_match();
2003 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* temp = _impl_.match_.atrace_msg_;
2004 _impl_.match_.atrace_msg_ = nullptr;
2005 return temp;
2006 } else {
2007 return nullptr;
2008 }
2009 }
unsafe_arena_set_allocated_atrace_msg(::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage * atrace_msg)2010 inline void FtraceConfig_PrintFilter_Rule::unsafe_arena_set_allocated_atrace_msg(::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* atrace_msg) {
2011 clear_match();
2012 if (atrace_msg) {
2013 set_has_atrace_msg();
2014 _impl_.match_.atrace_msg_ = atrace_msg;
2015 }
2016 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.FtraceConfig.PrintFilter.Rule.atrace_msg)
2017 }
_internal_mutable_atrace_msg()2018 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* FtraceConfig_PrintFilter_Rule::_internal_mutable_atrace_msg() {
2019 if (!_internal_has_atrace_msg()) {
2020 clear_match();
2021 set_has_atrace_msg();
2022 _impl_.match_.atrace_msg_ = CreateMaybeMessage< ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage >(GetArenaForAllocation());
2023 }
2024 return _impl_.match_.atrace_msg_;
2025 }
mutable_atrace_msg()2026 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* FtraceConfig_PrintFilter_Rule::mutable_atrace_msg() {
2027 ::perfetto::protos::FtraceConfig_PrintFilter_Rule_AtraceMessage* _msg = _internal_mutable_atrace_msg();
2028 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.PrintFilter.Rule.atrace_msg)
2029 return _msg;
2030 }
2031
2032 // optional bool allow = 2;
_internal_has_allow()2033 inline bool FtraceConfig_PrintFilter_Rule::_internal_has_allow() const {
2034 bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;
2035 return value;
2036 }
has_allow()2037 inline bool FtraceConfig_PrintFilter_Rule::has_allow() const {
2038 return _internal_has_allow();
2039 }
clear_allow()2040 inline void FtraceConfig_PrintFilter_Rule::clear_allow() {
2041 _impl_.allow_ = false;
2042 _impl_._has_bits_[0] &= ~0x00000001u;
2043 }
_internal_allow()2044 inline bool FtraceConfig_PrintFilter_Rule::_internal_allow() const {
2045 return _impl_.allow_;
2046 }
allow()2047 inline bool FtraceConfig_PrintFilter_Rule::allow() const {
2048 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.PrintFilter.Rule.allow)
2049 return _internal_allow();
2050 }
_internal_set_allow(bool value)2051 inline void FtraceConfig_PrintFilter_Rule::_internal_set_allow(bool value) {
2052 _impl_._has_bits_[0] |= 0x00000001u;
2053 _impl_.allow_ = value;
2054 }
set_allow(bool value)2055 inline void FtraceConfig_PrintFilter_Rule::set_allow(bool value) {
2056 _internal_set_allow(value);
2057 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.PrintFilter.Rule.allow)
2058 }
2059
has_match()2060 inline bool FtraceConfig_PrintFilter_Rule::has_match() const {
2061 return match_case() != MATCH_NOT_SET;
2062 }
clear_has_match()2063 inline void FtraceConfig_PrintFilter_Rule::clear_has_match() {
2064 _impl_._oneof_case_[0] = MATCH_NOT_SET;
2065 }
match_case()2066 inline FtraceConfig_PrintFilter_Rule::MatchCase FtraceConfig_PrintFilter_Rule::match_case() const {
2067 return FtraceConfig_PrintFilter_Rule::MatchCase(_impl_._oneof_case_[0]);
2068 }
2069 // -------------------------------------------------------------------
2070
2071 // FtraceConfig_PrintFilter
2072
2073 // repeated .perfetto.protos.FtraceConfig.PrintFilter.Rule rules = 1;
_internal_rules_size()2074 inline int FtraceConfig_PrintFilter::_internal_rules_size() const {
2075 return _impl_.rules_.size();
2076 }
rules_size()2077 inline int FtraceConfig_PrintFilter::rules_size() const {
2078 return _internal_rules_size();
2079 }
clear_rules()2080 inline void FtraceConfig_PrintFilter::clear_rules() {
2081 _impl_.rules_.Clear();
2082 }
mutable_rules(int index)2083 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule* FtraceConfig_PrintFilter::mutable_rules(int index) {
2084 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.PrintFilter.rules)
2085 return _impl_.rules_.Mutable(index);
2086 }
2087 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_PrintFilter_Rule >*
mutable_rules()2088 FtraceConfig_PrintFilter::mutable_rules() {
2089 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.PrintFilter.rules)
2090 return &_impl_.rules_;
2091 }
_internal_rules(int index)2092 inline const ::perfetto::protos::FtraceConfig_PrintFilter_Rule& FtraceConfig_PrintFilter::_internal_rules(int index) const {
2093 return _impl_.rules_.Get(index);
2094 }
rules(int index)2095 inline const ::perfetto::protos::FtraceConfig_PrintFilter_Rule& FtraceConfig_PrintFilter::rules(int index) const {
2096 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.PrintFilter.rules)
2097 return _internal_rules(index);
2098 }
_internal_add_rules()2099 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule* FtraceConfig_PrintFilter::_internal_add_rules() {
2100 return _impl_.rules_.Add();
2101 }
add_rules()2102 inline ::perfetto::protos::FtraceConfig_PrintFilter_Rule* FtraceConfig_PrintFilter::add_rules() {
2103 ::perfetto::protos::FtraceConfig_PrintFilter_Rule* _add = _internal_add_rules();
2104 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.PrintFilter.rules)
2105 return _add;
2106 }
2107 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_PrintFilter_Rule >&
rules()2108 FtraceConfig_PrintFilter::rules() const {
2109 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.PrintFilter.rules)
2110 return _impl_.rules_;
2111 }
2112
2113 // -------------------------------------------------------------------
2114
2115 // FtraceConfig
2116
2117 // repeated string ftrace_events = 1;
_internal_ftrace_events_size()2118 inline int FtraceConfig::_internal_ftrace_events_size() const {
2119 return _impl_.ftrace_events_.size();
2120 }
ftrace_events_size()2121 inline int FtraceConfig::ftrace_events_size() const {
2122 return _internal_ftrace_events_size();
2123 }
clear_ftrace_events()2124 inline void FtraceConfig::clear_ftrace_events() {
2125 _impl_.ftrace_events_.Clear();
2126 }
add_ftrace_events()2127 inline std::string* FtraceConfig::add_ftrace_events() {
2128 std::string* _s = _internal_add_ftrace_events();
2129 // @@protoc_insertion_point(field_add_mutable:perfetto.protos.FtraceConfig.ftrace_events)
2130 return _s;
2131 }
_internal_ftrace_events(int index)2132 inline const std::string& FtraceConfig::_internal_ftrace_events(int index) const {
2133 return _impl_.ftrace_events_.Get(index);
2134 }
ftrace_events(int index)2135 inline const std::string& FtraceConfig::ftrace_events(int index) const {
2136 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.ftrace_events)
2137 return _internal_ftrace_events(index);
2138 }
mutable_ftrace_events(int index)2139 inline std::string* FtraceConfig::mutable_ftrace_events(int index) {
2140 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.ftrace_events)
2141 return _impl_.ftrace_events_.Mutable(index);
2142 }
set_ftrace_events(int index,const std::string & value)2143 inline void FtraceConfig::set_ftrace_events(int index, const std::string& value) {
2144 _impl_.ftrace_events_.Mutable(index)->assign(value);
2145 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.ftrace_events)
2146 }
set_ftrace_events(int index,std::string && value)2147 inline void FtraceConfig::set_ftrace_events(int index, std::string&& value) {
2148 _impl_.ftrace_events_.Mutable(index)->assign(std::move(value));
2149 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.ftrace_events)
2150 }
set_ftrace_events(int index,const char * value)2151 inline void FtraceConfig::set_ftrace_events(int index, const char* value) {
2152 GOOGLE_DCHECK(value != nullptr);
2153 _impl_.ftrace_events_.Mutable(index)->assign(value);
2154 // @@protoc_insertion_point(field_set_char:perfetto.protos.FtraceConfig.ftrace_events)
2155 }
set_ftrace_events(int index,const char * value,size_t size)2156 inline void FtraceConfig::set_ftrace_events(int index, const char* value, size_t size) {
2157 _impl_.ftrace_events_.Mutable(index)->assign(
2158 reinterpret_cast<const char*>(value), size);
2159 // @@protoc_insertion_point(field_set_pointer:perfetto.protos.FtraceConfig.ftrace_events)
2160 }
_internal_add_ftrace_events()2161 inline std::string* FtraceConfig::_internal_add_ftrace_events() {
2162 return _impl_.ftrace_events_.Add();
2163 }
add_ftrace_events(const std::string & value)2164 inline void FtraceConfig::add_ftrace_events(const std::string& value) {
2165 _impl_.ftrace_events_.Add()->assign(value);
2166 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.ftrace_events)
2167 }
add_ftrace_events(std::string && value)2168 inline void FtraceConfig::add_ftrace_events(std::string&& value) {
2169 _impl_.ftrace_events_.Add(std::move(value));
2170 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.ftrace_events)
2171 }
add_ftrace_events(const char * value)2172 inline void FtraceConfig::add_ftrace_events(const char* value) {
2173 GOOGLE_DCHECK(value != nullptr);
2174 _impl_.ftrace_events_.Add()->assign(value);
2175 // @@protoc_insertion_point(field_add_char:perfetto.protos.FtraceConfig.ftrace_events)
2176 }
add_ftrace_events(const char * value,size_t size)2177 inline void FtraceConfig::add_ftrace_events(const char* value, size_t size) {
2178 _impl_.ftrace_events_.Add()->assign(reinterpret_cast<const char*>(value), size);
2179 // @@protoc_insertion_point(field_add_pointer:perfetto.protos.FtraceConfig.ftrace_events)
2180 }
2181 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
ftrace_events()2182 FtraceConfig::ftrace_events() const {
2183 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.ftrace_events)
2184 return _impl_.ftrace_events_;
2185 }
2186 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_ftrace_events()2187 FtraceConfig::mutable_ftrace_events() {
2188 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.ftrace_events)
2189 return &_impl_.ftrace_events_;
2190 }
2191
2192 // repeated .perfetto.protos.FtraceConfig.KprobeEvent kprobe_events = 30;
_internal_kprobe_events_size()2193 inline int FtraceConfig::_internal_kprobe_events_size() const {
2194 return _impl_.kprobe_events_.size();
2195 }
kprobe_events_size()2196 inline int FtraceConfig::kprobe_events_size() const {
2197 return _internal_kprobe_events_size();
2198 }
clear_kprobe_events()2199 inline void FtraceConfig::clear_kprobe_events() {
2200 _impl_.kprobe_events_.Clear();
2201 }
mutable_kprobe_events(int index)2202 inline ::perfetto::protos::FtraceConfig_KprobeEvent* FtraceConfig::mutable_kprobe_events(int index) {
2203 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.kprobe_events)
2204 return _impl_.kprobe_events_.Mutable(index);
2205 }
2206 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_KprobeEvent >*
mutable_kprobe_events()2207 FtraceConfig::mutable_kprobe_events() {
2208 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.kprobe_events)
2209 return &_impl_.kprobe_events_;
2210 }
_internal_kprobe_events(int index)2211 inline const ::perfetto::protos::FtraceConfig_KprobeEvent& FtraceConfig::_internal_kprobe_events(int index) const {
2212 return _impl_.kprobe_events_.Get(index);
2213 }
kprobe_events(int index)2214 inline const ::perfetto::protos::FtraceConfig_KprobeEvent& FtraceConfig::kprobe_events(int index) const {
2215 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.kprobe_events)
2216 return _internal_kprobe_events(index);
2217 }
_internal_add_kprobe_events()2218 inline ::perfetto::protos::FtraceConfig_KprobeEvent* FtraceConfig::_internal_add_kprobe_events() {
2219 return _impl_.kprobe_events_.Add();
2220 }
add_kprobe_events()2221 inline ::perfetto::protos::FtraceConfig_KprobeEvent* FtraceConfig::add_kprobe_events() {
2222 ::perfetto::protos::FtraceConfig_KprobeEvent* _add = _internal_add_kprobe_events();
2223 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.kprobe_events)
2224 return _add;
2225 }
2226 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::perfetto::protos::FtraceConfig_KprobeEvent >&
kprobe_events()2227 FtraceConfig::kprobe_events() const {
2228 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.kprobe_events)
2229 return _impl_.kprobe_events_;
2230 }
2231
2232 // repeated string atrace_categories = 2;
_internal_atrace_categories_size()2233 inline int FtraceConfig::_internal_atrace_categories_size() const {
2234 return _impl_.atrace_categories_.size();
2235 }
atrace_categories_size()2236 inline int FtraceConfig::atrace_categories_size() const {
2237 return _internal_atrace_categories_size();
2238 }
clear_atrace_categories()2239 inline void FtraceConfig::clear_atrace_categories() {
2240 _impl_.atrace_categories_.Clear();
2241 }
add_atrace_categories()2242 inline std::string* FtraceConfig::add_atrace_categories() {
2243 std::string* _s = _internal_add_atrace_categories();
2244 // @@protoc_insertion_point(field_add_mutable:perfetto.protos.FtraceConfig.atrace_categories)
2245 return _s;
2246 }
_internal_atrace_categories(int index)2247 inline const std::string& FtraceConfig::_internal_atrace_categories(int index) const {
2248 return _impl_.atrace_categories_.Get(index);
2249 }
atrace_categories(int index)2250 inline const std::string& FtraceConfig::atrace_categories(int index) const {
2251 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.atrace_categories)
2252 return _internal_atrace_categories(index);
2253 }
mutable_atrace_categories(int index)2254 inline std::string* FtraceConfig::mutable_atrace_categories(int index) {
2255 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.atrace_categories)
2256 return _impl_.atrace_categories_.Mutable(index);
2257 }
set_atrace_categories(int index,const std::string & value)2258 inline void FtraceConfig::set_atrace_categories(int index, const std::string& value) {
2259 _impl_.atrace_categories_.Mutable(index)->assign(value);
2260 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.atrace_categories)
2261 }
set_atrace_categories(int index,std::string && value)2262 inline void FtraceConfig::set_atrace_categories(int index, std::string&& value) {
2263 _impl_.atrace_categories_.Mutable(index)->assign(std::move(value));
2264 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.atrace_categories)
2265 }
set_atrace_categories(int index,const char * value)2266 inline void FtraceConfig::set_atrace_categories(int index, const char* value) {
2267 GOOGLE_DCHECK(value != nullptr);
2268 _impl_.atrace_categories_.Mutable(index)->assign(value);
2269 // @@protoc_insertion_point(field_set_char:perfetto.protos.FtraceConfig.atrace_categories)
2270 }
set_atrace_categories(int index,const char * value,size_t size)2271 inline void FtraceConfig::set_atrace_categories(int index, const char* value, size_t size) {
2272 _impl_.atrace_categories_.Mutable(index)->assign(
2273 reinterpret_cast<const char*>(value), size);
2274 // @@protoc_insertion_point(field_set_pointer:perfetto.protos.FtraceConfig.atrace_categories)
2275 }
_internal_add_atrace_categories()2276 inline std::string* FtraceConfig::_internal_add_atrace_categories() {
2277 return _impl_.atrace_categories_.Add();
2278 }
add_atrace_categories(const std::string & value)2279 inline void FtraceConfig::add_atrace_categories(const std::string& value) {
2280 _impl_.atrace_categories_.Add()->assign(value);
2281 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.atrace_categories)
2282 }
add_atrace_categories(std::string && value)2283 inline void FtraceConfig::add_atrace_categories(std::string&& value) {
2284 _impl_.atrace_categories_.Add(std::move(value));
2285 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.atrace_categories)
2286 }
add_atrace_categories(const char * value)2287 inline void FtraceConfig::add_atrace_categories(const char* value) {
2288 GOOGLE_DCHECK(value != nullptr);
2289 _impl_.atrace_categories_.Add()->assign(value);
2290 // @@protoc_insertion_point(field_add_char:perfetto.protos.FtraceConfig.atrace_categories)
2291 }
add_atrace_categories(const char * value,size_t size)2292 inline void FtraceConfig::add_atrace_categories(const char* value, size_t size) {
2293 _impl_.atrace_categories_.Add()->assign(reinterpret_cast<const char*>(value), size);
2294 // @@protoc_insertion_point(field_add_pointer:perfetto.protos.FtraceConfig.atrace_categories)
2295 }
2296 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
atrace_categories()2297 FtraceConfig::atrace_categories() const {
2298 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.atrace_categories)
2299 return _impl_.atrace_categories_;
2300 }
2301 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_atrace_categories()2302 FtraceConfig::mutable_atrace_categories() {
2303 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.atrace_categories)
2304 return &_impl_.atrace_categories_;
2305 }
2306
2307 // repeated string atrace_apps = 3;
_internal_atrace_apps_size()2308 inline int FtraceConfig::_internal_atrace_apps_size() const {
2309 return _impl_.atrace_apps_.size();
2310 }
atrace_apps_size()2311 inline int FtraceConfig::atrace_apps_size() const {
2312 return _internal_atrace_apps_size();
2313 }
clear_atrace_apps()2314 inline void FtraceConfig::clear_atrace_apps() {
2315 _impl_.atrace_apps_.Clear();
2316 }
add_atrace_apps()2317 inline std::string* FtraceConfig::add_atrace_apps() {
2318 std::string* _s = _internal_add_atrace_apps();
2319 // @@protoc_insertion_point(field_add_mutable:perfetto.protos.FtraceConfig.atrace_apps)
2320 return _s;
2321 }
_internal_atrace_apps(int index)2322 inline const std::string& FtraceConfig::_internal_atrace_apps(int index) const {
2323 return _impl_.atrace_apps_.Get(index);
2324 }
atrace_apps(int index)2325 inline const std::string& FtraceConfig::atrace_apps(int index) const {
2326 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.atrace_apps)
2327 return _internal_atrace_apps(index);
2328 }
mutable_atrace_apps(int index)2329 inline std::string* FtraceConfig::mutable_atrace_apps(int index) {
2330 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.atrace_apps)
2331 return _impl_.atrace_apps_.Mutable(index);
2332 }
set_atrace_apps(int index,const std::string & value)2333 inline void FtraceConfig::set_atrace_apps(int index, const std::string& value) {
2334 _impl_.atrace_apps_.Mutable(index)->assign(value);
2335 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.atrace_apps)
2336 }
set_atrace_apps(int index,std::string && value)2337 inline void FtraceConfig::set_atrace_apps(int index, std::string&& value) {
2338 _impl_.atrace_apps_.Mutable(index)->assign(std::move(value));
2339 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.atrace_apps)
2340 }
set_atrace_apps(int index,const char * value)2341 inline void FtraceConfig::set_atrace_apps(int index, const char* value) {
2342 GOOGLE_DCHECK(value != nullptr);
2343 _impl_.atrace_apps_.Mutable(index)->assign(value);
2344 // @@protoc_insertion_point(field_set_char:perfetto.protos.FtraceConfig.atrace_apps)
2345 }
set_atrace_apps(int index,const char * value,size_t size)2346 inline void FtraceConfig::set_atrace_apps(int index, const char* value, size_t size) {
2347 _impl_.atrace_apps_.Mutable(index)->assign(
2348 reinterpret_cast<const char*>(value), size);
2349 // @@protoc_insertion_point(field_set_pointer:perfetto.protos.FtraceConfig.atrace_apps)
2350 }
_internal_add_atrace_apps()2351 inline std::string* FtraceConfig::_internal_add_atrace_apps() {
2352 return _impl_.atrace_apps_.Add();
2353 }
add_atrace_apps(const std::string & value)2354 inline void FtraceConfig::add_atrace_apps(const std::string& value) {
2355 _impl_.atrace_apps_.Add()->assign(value);
2356 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.atrace_apps)
2357 }
add_atrace_apps(std::string && value)2358 inline void FtraceConfig::add_atrace_apps(std::string&& value) {
2359 _impl_.atrace_apps_.Add(std::move(value));
2360 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.atrace_apps)
2361 }
add_atrace_apps(const char * value)2362 inline void FtraceConfig::add_atrace_apps(const char* value) {
2363 GOOGLE_DCHECK(value != nullptr);
2364 _impl_.atrace_apps_.Add()->assign(value);
2365 // @@protoc_insertion_point(field_add_char:perfetto.protos.FtraceConfig.atrace_apps)
2366 }
add_atrace_apps(const char * value,size_t size)2367 inline void FtraceConfig::add_atrace_apps(const char* value, size_t size) {
2368 _impl_.atrace_apps_.Add()->assign(reinterpret_cast<const char*>(value), size);
2369 // @@protoc_insertion_point(field_add_pointer:perfetto.protos.FtraceConfig.atrace_apps)
2370 }
2371 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
atrace_apps()2372 FtraceConfig::atrace_apps() const {
2373 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.atrace_apps)
2374 return _impl_.atrace_apps_;
2375 }
2376 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_atrace_apps()2377 FtraceConfig::mutable_atrace_apps() {
2378 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.atrace_apps)
2379 return &_impl_.atrace_apps_;
2380 }
2381
2382 // repeated string atrace_categories_prefer_sdk = 28;
_internal_atrace_categories_prefer_sdk_size()2383 inline int FtraceConfig::_internal_atrace_categories_prefer_sdk_size() const {
2384 return _impl_.atrace_categories_prefer_sdk_.size();
2385 }
atrace_categories_prefer_sdk_size()2386 inline int FtraceConfig::atrace_categories_prefer_sdk_size() const {
2387 return _internal_atrace_categories_prefer_sdk_size();
2388 }
clear_atrace_categories_prefer_sdk()2389 inline void FtraceConfig::clear_atrace_categories_prefer_sdk() {
2390 _impl_.atrace_categories_prefer_sdk_.Clear();
2391 }
add_atrace_categories_prefer_sdk()2392 inline std::string* FtraceConfig::add_atrace_categories_prefer_sdk() {
2393 std::string* _s = _internal_add_atrace_categories_prefer_sdk();
2394 // @@protoc_insertion_point(field_add_mutable:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2395 return _s;
2396 }
_internal_atrace_categories_prefer_sdk(int index)2397 inline const std::string& FtraceConfig::_internal_atrace_categories_prefer_sdk(int index) const {
2398 return _impl_.atrace_categories_prefer_sdk_.Get(index);
2399 }
atrace_categories_prefer_sdk(int index)2400 inline const std::string& FtraceConfig::atrace_categories_prefer_sdk(int index) const {
2401 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2402 return _internal_atrace_categories_prefer_sdk(index);
2403 }
mutable_atrace_categories_prefer_sdk(int index)2404 inline std::string* FtraceConfig::mutable_atrace_categories_prefer_sdk(int index) {
2405 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2406 return _impl_.atrace_categories_prefer_sdk_.Mutable(index);
2407 }
set_atrace_categories_prefer_sdk(int index,const std::string & value)2408 inline void FtraceConfig::set_atrace_categories_prefer_sdk(int index, const std::string& value) {
2409 _impl_.atrace_categories_prefer_sdk_.Mutable(index)->assign(value);
2410 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2411 }
set_atrace_categories_prefer_sdk(int index,std::string && value)2412 inline void FtraceConfig::set_atrace_categories_prefer_sdk(int index, std::string&& value) {
2413 _impl_.atrace_categories_prefer_sdk_.Mutable(index)->assign(std::move(value));
2414 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2415 }
set_atrace_categories_prefer_sdk(int index,const char * value)2416 inline void FtraceConfig::set_atrace_categories_prefer_sdk(int index, const char* value) {
2417 GOOGLE_DCHECK(value != nullptr);
2418 _impl_.atrace_categories_prefer_sdk_.Mutable(index)->assign(value);
2419 // @@protoc_insertion_point(field_set_char:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2420 }
set_atrace_categories_prefer_sdk(int index,const char * value,size_t size)2421 inline void FtraceConfig::set_atrace_categories_prefer_sdk(int index, const char* value, size_t size) {
2422 _impl_.atrace_categories_prefer_sdk_.Mutable(index)->assign(
2423 reinterpret_cast<const char*>(value), size);
2424 // @@protoc_insertion_point(field_set_pointer:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2425 }
_internal_add_atrace_categories_prefer_sdk()2426 inline std::string* FtraceConfig::_internal_add_atrace_categories_prefer_sdk() {
2427 return _impl_.atrace_categories_prefer_sdk_.Add();
2428 }
add_atrace_categories_prefer_sdk(const std::string & value)2429 inline void FtraceConfig::add_atrace_categories_prefer_sdk(const std::string& value) {
2430 _impl_.atrace_categories_prefer_sdk_.Add()->assign(value);
2431 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2432 }
add_atrace_categories_prefer_sdk(std::string && value)2433 inline void FtraceConfig::add_atrace_categories_prefer_sdk(std::string&& value) {
2434 _impl_.atrace_categories_prefer_sdk_.Add(std::move(value));
2435 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2436 }
add_atrace_categories_prefer_sdk(const char * value)2437 inline void FtraceConfig::add_atrace_categories_prefer_sdk(const char* value) {
2438 GOOGLE_DCHECK(value != nullptr);
2439 _impl_.atrace_categories_prefer_sdk_.Add()->assign(value);
2440 // @@protoc_insertion_point(field_add_char:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2441 }
add_atrace_categories_prefer_sdk(const char * value,size_t size)2442 inline void FtraceConfig::add_atrace_categories_prefer_sdk(const char* value, size_t size) {
2443 _impl_.atrace_categories_prefer_sdk_.Add()->assign(reinterpret_cast<const char*>(value), size);
2444 // @@protoc_insertion_point(field_add_pointer:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2445 }
2446 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
atrace_categories_prefer_sdk()2447 FtraceConfig::atrace_categories_prefer_sdk() const {
2448 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2449 return _impl_.atrace_categories_prefer_sdk_;
2450 }
2451 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_atrace_categories_prefer_sdk()2452 FtraceConfig::mutable_atrace_categories_prefer_sdk() {
2453 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.atrace_categories_prefer_sdk)
2454 return &_impl_.atrace_categories_prefer_sdk_;
2455 }
2456
2457 // optional uint32 buffer_size_kb = 10;
_internal_has_buffer_size_kb()2458 inline bool FtraceConfig::_internal_has_buffer_size_kb() const {
2459 bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;
2460 return value;
2461 }
has_buffer_size_kb()2462 inline bool FtraceConfig::has_buffer_size_kb() const {
2463 return _internal_has_buffer_size_kb();
2464 }
clear_buffer_size_kb()2465 inline void FtraceConfig::clear_buffer_size_kb() {
2466 _impl_.buffer_size_kb_ = 0u;
2467 _impl_._has_bits_[0] &= ~0x00000008u;
2468 }
_internal_buffer_size_kb()2469 inline ::uint32_t FtraceConfig::_internal_buffer_size_kb() const {
2470 return _impl_.buffer_size_kb_;
2471 }
buffer_size_kb()2472 inline ::uint32_t FtraceConfig::buffer_size_kb() const {
2473 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.buffer_size_kb)
2474 return _internal_buffer_size_kb();
2475 }
_internal_set_buffer_size_kb(::uint32_t value)2476 inline void FtraceConfig::_internal_set_buffer_size_kb(::uint32_t value) {
2477 _impl_._has_bits_[0] |= 0x00000008u;
2478 _impl_.buffer_size_kb_ = value;
2479 }
set_buffer_size_kb(::uint32_t value)2480 inline void FtraceConfig::set_buffer_size_kb(::uint32_t value) {
2481 _internal_set_buffer_size_kb(value);
2482 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.buffer_size_kb)
2483 }
2484
2485 // optional uint32 drain_period_ms = 11;
_internal_has_drain_period_ms()2486 inline bool FtraceConfig::_internal_has_drain_period_ms() const {
2487 bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;
2488 return value;
2489 }
has_drain_period_ms()2490 inline bool FtraceConfig::has_drain_period_ms() const {
2491 return _internal_has_drain_period_ms();
2492 }
clear_drain_period_ms()2493 inline void FtraceConfig::clear_drain_period_ms() {
2494 _impl_.drain_period_ms_ = 0u;
2495 _impl_._has_bits_[0] &= ~0x00000010u;
2496 }
_internal_drain_period_ms()2497 inline ::uint32_t FtraceConfig::_internal_drain_period_ms() const {
2498 return _impl_.drain_period_ms_;
2499 }
drain_period_ms()2500 inline ::uint32_t FtraceConfig::drain_period_ms() const {
2501 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.drain_period_ms)
2502 return _internal_drain_period_ms();
2503 }
_internal_set_drain_period_ms(::uint32_t value)2504 inline void FtraceConfig::_internal_set_drain_period_ms(::uint32_t value) {
2505 _impl_._has_bits_[0] |= 0x00000010u;
2506 _impl_.drain_period_ms_ = value;
2507 }
set_drain_period_ms(::uint32_t value)2508 inline void FtraceConfig::set_drain_period_ms(::uint32_t value) {
2509 _internal_set_drain_period_ms(value);
2510 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.drain_period_ms)
2511 }
2512
2513 // optional uint32 drain_buffer_percent = 29;
_internal_has_drain_buffer_percent()2514 inline bool FtraceConfig::_internal_has_drain_buffer_percent() const {
2515 bool value = (_impl_._has_bits_[0] & 0x00004000u) != 0;
2516 return value;
2517 }
has_drain_buffer_percent()2518 inline bool FtraceConfig::has_drain_buffer_percent() const {
2519 return _internal_has_drain_buffer_percent();
2520 }
clear_drain_buffer_percent()2521 inline void FtraceConfig::clear_drain_buffer_percent() {
2522 _impl_.drain_buffer_percent_ = 0u;
2523 _impl_._has_bits_[0] &= ~0x00004000u;
2524 }
_internal_drain_buffer_percent()2525 inline ::uint32_t FtraceConfig::_internal_drain_buffer_percent() const {
2526 return _impl_.drain_buffer_percent_;
2527 }
drain_buffer_percent()2528 inline ::uint32_t FtraceConfig::drain_buffer_percent() const {
2529 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.drain_buffer_percent)
2530 return _internal_drain_buffer_percent();
2531 }
_internal_set_drain_buffer_percent(::uint32_t value)2532 inline void FtraceConfig::_internal_set_drain_buffer_percent(::uint32_t value) {
2533 _impl_._has_bits_[0] |= 0x00004000u;
2534 _impl_.drain_buffer_percent_ = value;
2535 }
set_drain_buffer_percent(::uint32_t value)2536 inline void FtraceConfig::set_drain_buffer_percent(::uint32_t value) {
2537 _internal_set_drain_buffer_percent(value);
2538 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.drain_buffer_percent)
2539 }
2540
2541 // optional .perfetto.protos.FtraceConfig.CompactSchedConfig compact_sched = 12;
_internal_has_compact_sched()2542 inline bool FtraceConfig::_internal_has_compact_sched() const {
2543 bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;
2544 PROTOBUF_ASSUME(!value || _impl_.compact_sched_ != nullptr);
2545 return value;
2546 }
has_compact_sched()2547 inline bool FtraceConfig::has_compact_sched() const {
2548 return _internal_has_compact_sched();
2549 }
clear_compact_sched()2550 inline void FtraceConfig::clear_compact_sched() {
2551 if (_impl_.compact_sched_ != nullptr) _impl_.compact_sched_->Clear();
2552 _impl_._has_bits_[0] &= ~0x00000002u;
2553 }
_internal_compact_sched()2554 inline const ::perfetto::protos::FtraceConfig_CompactSchedConfig& FtraceConfig::_internal_compact_sched() const {
2555 const ::perfetto::protos::FtraceConfig_CompactSchedConfig* p = _impl_.compact_sched_;
2556 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::FtraceConfig_CompactSchedConfig&>(
2557 ::perfetto::protos::_FtraceConfig_CompactSchedConfig_default_instance_);
2558 }
compact_sched()2559 inline const ::perfetto::protos::FtraceConfig_CompactSchedConfig& FtraceConfig::compact_sched() const {
2560 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.compact_sched)
2561 return _internal_compact_sched();
2562 }
unsafe_arena_set_allocated_compact_sched(::perfetto::protos::FtraceConfig_CompactSchedConfig * compact_sched)2563 inline void FtraceConfig::unsafe_arena_set_allocated_compact_sched(
2564 ::perfetto::protos::FtraceConfig_CompactSchedConfig* compact_sched) {
2565 if (GetArenaForAllocation() == nullptr) {
2566 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.compact_sched_);
2567 }
2568 _impl_.compact_sched_ = compact_sched;
2569 if (compact_sched) {
2570 _impl_._has_bits_[0] |= 0x00000002u;
2571 } else {
2572 _impl_._has_bits_[0] &= ~0x00000002u;
2573 }
2574 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.FtraceConfig.compact_sched)
2575 }
release_compact_sched()2576 inline ::perfetto::protos::FtraceConfig_CompactSchedConfig* FtraceConfig::release_compact_sched() {
2577 _impl_._has_bits_[0] &= ~0x00000002u;
2578 ::perfetto::protos::FtraceConfig_CompactSchedConfig* temp = _impl_.compact_sched_;
2579 _impl_.compact_sched_ = nullptr;
2580 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2581 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2582 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2583 if (GetArenaForAllocation() == nullptr) { delete old; }
2584 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2585 if (GetArenaForAllocation() != nullptr) {
2586 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2587 }
2588 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2589 return temp;
2590 }
unsafe_arena_release_compact_sched()2591 inline ::perfetto::protos::FtraceConfig_CompactSchedConfig* FtraceConfig::unsafe_arena_release_compact_sched() {
2592 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.compact_sched)
2593 _impl_._has_bits_[0] &= ~0x00000002u;
2594 ::perfetto::protos::FtraceConfig_CompactSchedConfig* temp = _impl_.compact_sched_;
2595 _impl_.compact_sched_ = nullptr;
2596 return temp;
2597 }
_internal_mutable_compact_sched()2598 inline ::perfetto::protos::FtraceConfig_CompactSchedConfig* FtraceConfig::_internal_mutable_compact_sched() {
2599 _impl_._has_bits_[0] |= 0x00000002u;
2600 if (_impl_.compact_sched_ == nullptr) {
2601 auto* p = CreateMaybeMessage<::perfetto::protos::FtraceConfig_CompactSchedConfig>(GetArenaForAllocation());
2602 _impl_.compact_sched_ = p;
2603 }
2604 return _impl_.compact_sched_;
2605 }
mutable_compact_sched()2606 inline ::perfetto::protos::FtraceConfig_CompactSchedConfig* FtraceConfig::mutable_compact_sched() {
2607 ::perfetto::protos::FtraceConfig_CompactSchedConfig* _msg = _internal_mutable_compact_sched();
2608 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.compact_sched)
2609 return _msg;
2610 }
set_allocated_compact_sched(::perfetto::protos::FtraceConfig_CompactSchedConfig * compact_sched)2611 inline void FtraceConfig::set_allocated_compact_sched(::perfetto::protos::FtraceConfig_CompactSchedConfig* compact_sched) {
2612 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2613 if (message_arena == nullptr) {
2614 delete _impl_.compact_sched_;
2615 }
2616 if (compact_sched) {
2617 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2618 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(compact_sched);
2619 if (message_arena != submessage_arena) {
2620 compact_sched = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2621 message_arena, compact_sched, submessage_arena);
2622 }
2623 _impl_._has_bits_[0] |= 0x00000002u;
2624 } else {
2625 _impl_._has_bits_[0] &= ~0x00000002u;
2626 }
2627 _impl_.compact_sched_ = compact_sched;
2628 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FtraceConfig.compact_sched)
2629 }
2630
2631 // optional .perfetto.protos.FtraceConfig.PrintFilter print_filter = 22;
_internal_has_print_filter()2632 inline bool FtraceConfig::_internal_has_print_filter() const {
2633 bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;
2634 PROTOBUF_ASSUME(!value || _impl_.print_filter_ != nullptr);
2635 return value;
2636 }
has_print_filter()2637 inline bool FtraceConfig::has_print_filter() const {
2638 return _internal_has_print_filter();
2639 }
clear_print_filter()2640 inline void FtraceConfig::clear_print_filter() {
2641 if (_impl_.print_filter_ != nullptr) _impl_.print_filter_->Clear();
2642 _impl_._has_bits_[0] &= ~0x00000004u;
2643 }
_internal_print_filter()2644 inline const ::perfetto::protos::FtraceConfig_PrintFilter& FtraceConfig::_internal_print_filter() const {
2645 const ::perfetto::protos::FtraceConfig_PrintFilter* p = _impl_.print_filter_;
2646 return p != nullptr ? *p : reinterpret_cast<const ::perfetto::protos::FtraceConfig_PrintFilter&>(
2647 ::perfetto::protos::_FtraceConfig_PrintFilter_default_instance_);
2648 }
print_filter()2649 inline const ::perfetto::protos::FtraceConfig_PrintFilter& FtraceConfig::print_filter() const {
2650 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.print_filter)
2651 return _internal_print_filter();
2652 }
unsafe_arena_set_allocated_print_filter(::perfetto::protos::FtraceConfig_PrintFilter * print_filter)2653 inline void FtraceConfig::unsafe_arena_set_allocated_print_filter(
2654 ::perfetto::protos::FtraceConfig_PrintFilter* print_filter) {
2655 if (GetArenaForAllocation() == nullptr) {
2656 delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.print_filter_);
2657 }
2658 _impl_.print_filter_ = print_filter;
2659 if (print_filter) {
2660 _impl_._has_bits_[0] |= 0x00000004u;
2661 } else {
2662 _impl_._has_bits_[0] &= ~0x00000004u;
2663 }
2664 // @@protoc_insertion_point(field_unsafe_arena_set_allocated:perfetto.protos.FtraceConfig.print_filter)
2665 }
release_print_filter()2666 inline ::perfetto::protos::FtraceConfig_PrintFilter* FtraceConfig::release_print_filter() {
2667 _impl_._has_bits_[0] &= ~0x00000004u;
2668 ::perfetto::protos::FtraceConfig_PrintFilter* temp = _impl_.print_filter_;
2669 _impl_.print_filter_ = nullptr;
2670 #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
2671 auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
2672 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2673 if (GetArenaForAllocation() == nullptr) { delete old; }
2674 #else // PROTOBUF_FORCE_COPY_IN_RELEASE
2675 if (GetArenaForAllocation() != nullptr) {
2676 temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
2677 }
2678 #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
2679 return temp;
2680 }
unsafe_arena_release_print_filter()2681 inline ::perfetto::protos::FtraceConfig_PrintFilter* FtraceConfig::unsafe_arena_release_print_filter() {
2682 // @@protoc_insertion_point(field_release:perfetto.protos.FtraceConfig.print_filter)
2683 _impl_._has_bits_[0] &= ~0x00000004u;
2684 ::perfetto::protos::FtraceConfig_PrintFilter* temp = _impl_.print_filter_;
2685 _impl_.print_filter_ = nullptr;
2686 return temp;
2687 }
_internal_mutable_print_filter()2688 inline ::perfetto::protos::FtraceConfig_PrintFilter* FtraceConfig::_internal_mutable_print_filter() {
2689 _impl_._has_bits_[0] |= 0x00000004u;
2690 if (_impl_.print_filter_ == nullptr) {
2691 auto* p = CreateMaybeMessage<::perfetto::protos::FtraceConfig_PrintFilter>(GetArenaForAllocation());
2692 _impl_.print_filter_ = p;
2693 }
2694 return _impl_.print_filter_;
2695 }
mutable_print_filter()2696 inline ::perfetto::protos::FtraceConfig_PrintFilter* FtraceConfig::mutable_print_filter() {
2697 ::perfetto::protos::FtraceConfig_PrintFilter* _msg = _internal_mutable_print_filter();
2698 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.print_filter)
2699 return _msg;
2700 }
set_allocated_print_filter(::perfetto::protos::FtraceConfig_PrintFilter * print_filter)2701 inline void FtraceConfig::set_allocated_print_filter(::perfetto::protos::FtraceConfig_PrintFilter* print_filter) {
2702 ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
2703 if (message_arena == nullptr) {
2704 delete _impl_.print_filter_;
2705 }
2706 if (print_filter) {
2707 ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
2708 ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(print_filter);
2709 if (message_arena != submessage_arena) {
2710 print_filter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
2711 message_arena, print_filter, submessage_arena);
2712 }
2713 _impl_._has_bits_[0] |= 0x00000004u;
2714 } else {
2715 _impl_._has_bits_[0] &= ~0x00000004u;
2716 }
2717 _impl_.print_filter_ = print_filter;
2718 // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FtraceConfig.print_filter)
2719 }
2720
2721 // optional bool symbolize_ksyms = 13;
_internal_has_symbolize_ksyms()2722 inline bool FtraceConfig::_internal_has_symbolize_ksyms() const {
2723 bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;
2724 return value;
2725 }
has_symbolize_ksyms()2726 inline bool FtraceConfig::has_symbolize_ksyms() const {
2727 return _internal_has_symbolize_ksyms();
2728 }
clear_symbolize_ksyms()2729 inline void FtraceConfig::clear_symbolize_ksyms() {
2730 _impl_.symbolize_ksyms_ = false;
2731 _impl_._has_bits_[0] &= ~0x00000020u;
2732 }
_internal_symbolize_ksyms()2733 inline bool FtraceConfig::_internal_symbolize_ksyms() const {
2734 return _impl_.symbolize_ksyms_;
2735 }
symbolize_ksyms()2736 inline bool FtraceConfig::symbolize_ksyms() const {
2737 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.symbolize_ksyms)
2738 return _internal_symbolize_ksyms();
2739 }
_internal_set_symbolize_ksyms(bool value)2740 inline void FtraceConfig::_internal_set_symbolize_ksyms(bool value) {
2741 _impl_._has_bits_[0] |= 0x00000020u;
2742 _impl_.symbolize_ksyms_ = value;
2743 }
set_symbolize_ksyms(bool value)2744 inline void FtraceConfig::set_symbolize_ksyms(bool value) {
2745 _internal_set_symbolize_ksyms(value);
2746 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.symbolize_ksyms)
2747 }
2748
2749 // optional .perfetto.protos.FtraceConfig.KsymsMemPolicy ksyms_mem_policy = 17;
_internal_has_ksyms_mem_policy()2750 inline bool FtraceConfig::_internal_has_ksyms_mem_policy() const {
2751 bool value = (_impl_._has_bits_[0] & 0x00000200u) != 0;
2752 return value;
2753 }
has_ksyms_mem_policy()2754 inline bool FtraceConfig::has_ksyms_mem_policy() const {
2755 return _internal_has_ksyms_mem_policy();
2756 }
clear_ksyms_mem_policy()2757 inline void FtraceConfig::clear_ksyms_mem_policy() {
2758 _impl_.ksyms_mem_policy_ = 0;
2759 _impl_._has_bits_[0] &= ~0x00000200u;
2760 }
_internal_ksyms_mem_policy()2761 inline ::perfetto::protos::FtraceConfig_KsymsMemPolicy FtraceConfig::_internal_ksyms_mem_policy() const {
2762 return static_cast< ::perfetto::protos::FtraceConfig_KsymsMemPolicy >(_impl_.ksyms_mem_policy_);
2763 }
ksyms_mem_policy()2764 inline ::perfetto::protos::FtraceConfig_KsymsMemPolicy FtraceConfig::ksyms_mem_policy() const {
2765 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.ksyms_mem_policy)
2766 return _internal_ksyms_mem_policy();
2767 }
_internal_set_ksyms_mem_policy(::perfetto::protos::FtraceConfig_KsymsMemPolicy value)2768 inline void FtraceConfig::_internal_set_ksyms_mem_policy(::perfetto::protos::FtraceConfig_KsymsMemPolicy value) {
2769 assert(::perfetto::protos::FtraceConfig_KsymsMemPolicy_IsValid(value));
2770 _impl_._has_bits_[0] |= 0x00000200u;
2771 _impl_.ksyms_mem_policy_ = value;
2772 }
set_ksyms_mem_policy(::perfetto::protos::FtraceConfig_KsymsMemPolicy value)2773 inline void FtraceConfig::set_ksyms_mem_policy(::perfetto::protos::FtraceConfig_KsymsMemPolicy value) {
2774 _internal_set_ksyms_mem_policy(value);
2775 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.ksyms_mem_policy)
2776 }
2777
2778 // optional bool initialize_ksyms_synchronously_for_testing = 14 [deprecated = true];
_internal_has_initialize_ksyms_synchronously_for_testing()2779 inline bool FtraceConfig::_internal_has_initialize_ksyms_synchronously_for_testing() const {
2780 bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;
2781 return value;
2782 }
has_initialize_ksyms_synchronously_for_testing()2783 inline bool FtraceConfig::has_initialize_ksyms_synchronously_for_testing() const {
2784 return _internal_has_initialize_ksyms_synchronously_for_testing();
2785 }
clear_initialize_ksyms_synchronously_for_testing()2786 inline void FtraceConfig::clear_initialize_ksyms_synchronously_for_testing() {
2787 _impl_.initialize_ksyms_synchronously_for_testing_ = false;
2788 _impl_._has_bits_[0] &= ~0x00000040u;
2789 }
_internal_initialize_ksyms_synchronously_for_testing()2790 inline bool FtraceConfig::_internal_initialize_ksyms_synchronously_for_testing() const {
2791 return _impl_.initialize_ksyms_synchronously_for_testing_;
2792 }
initialize_ksyms_synchronously_for_testing()2793 inline bool FtraceConfig::initialize_ksyms_synchronously_for_testing() const {
2794 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.initialize_ksyms_synchronously_for_testing)
2795 return _internal_initialize_ksyms_synchronously_for_testing();
2796 }
_internal_set_initialize_ksyms_synchronously_for_testing(bool value)2797 inline void FtraceConfig::_internal_set_initialize_ksyms_synchronously_for_testing(bool value) {
2798 _impl_._has_bits_[0] |= 0x00000040u;
2799 _impl_.initialize_ksyms_synchronously_for_testing_ = value;
2800 }
set_initialize_ksyms_synchronously_for_testing(bool value)2801 inline void FtraceConfig::set_initialize_ksyms_synchronously_for_testing(bool value) {
2802 _internal_set_initialize_ksyms_synchronously_for_testing(value);
2803 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.initialize_ksyms_synchronously_for_testing)
2804 }
2805
2806 // optional bool throttle_rss_stat = 15;
_internal_has_throttle_rss_stat()2807 inline bool FtraceConfig::_internal_has_throttle_rss_stat() const {
2808 bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;
2809 return value;
2810 }
has_throttle_rss_stat()2811 inline bool FtraceConfig::has_throttle_rss_stat() const {
2812 return _internal_has_throttle_rss_stat();
2813 }
clear_throttle_rss_stat()2814 inline void FtraceConfig::clear_throttle_rss_stat() {
2815 _impl_.throttle_rss_stat_ = false;
2816 _impl_._has_bits_[0] &= ~0x00000080u;
2817 }
_internal_throttle_rss_stat()2818 inline bool FtraceConfig::_internal_throttle_rss_stat() const {
2819 return _impl_.throttle_rss_stat_;
2820 }
throttle_rss_stat()2821 inline bool FtraceConfig::throttle_rss_stat() const {
2822 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.throttle_rss_stat)
2823 return _internal_throttle_rss_stat();
2824 }
_internal_set_throttle_rss_stat(bool value)2825 inline void FtraceConfig::_internal_set_throttle_rss_stat(bool value) {
2826 _impl_._has_bits_[0] |= 0x00000080u;
2827 _impl_.throttle_rss_stat_ = value;
2828 }
set_throttle_rss_stat(bool value)2829 inline void FtraceConfig::set_throttle_rss_stat(bool value) {
2830 _internal_set_throttle_rss_stat(value);
2831 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.throttle_rss_stat)
2832 }
2833
2834 // optional bool disable_generic_events = 16;
_internal_has_disable_generic_events()2835 inline bool FtraceConfig::_internal_has_disable_generic_events() const {
2836 bool value = (_impl_._has_bits_[0] & 0x00000100u) != 0;
2837 return value;
2838 }
has_disable_generic_events()2839 inline bool FtraceConfig::has_disable_generic_events() const {
2840 return _internal_has_disable_generic_events();
2841 }
clear_disable_generic_events()2842 inline void FtraceConfig::clear_disable_generic_events() {
2843 _impl_.disable_generic_events_ = false;
2844 _impl_._has_bits_[0] &= ~0x00000100u;
2845 }
_internal_disable_generic_events()2846 inline bool FtraceConfig::_internal_disable_generic_events() const {
2847 return _impl_.disable_generic_events_;
2848 }
disable_generic_events()2849 inline bool FtraceConfig::disable_generic_events() const {
2850 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.disable_generic_events)
2851 return _internal_disable_generic_events();
2852 }
_internal_set_disable_generic_events(bool value)2853 inline void FtraceConfig::_internal_set_disable_generic_events(bool value) {
2854 _impl_._has_bits_[0] |= 0x00000100u;
2855 _impl_.disable_generic_events_ = value;
2856 }
set_disable_generic_events(bool value)2857 inline void FtraceConfig::set_disable_generic_events(bool value) {
2858 _internal_set_disable_generic_events(value);
2859 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.disable_generic_events)
2860 }
2861
2862 // repeated string syscall_events = 18;
_internal_syscall_events_size()2863 inline int FtraceConfig::_internal_syscall_events_size() const {
2864 return _impl_.syscall_events_.size();
2865 }
syscall_events_size()2866 inline int FtraceConfig::syscall_events_size() const {
2867 return _internal_syscall_events_size();
2868 }
clear_syscall_events()2869 inline void FtraceConfig::clear_syscall_events() {
2870 _impl_.syscall_events_.Clear();
2871 }
add_syscall_events()2872 inline std::string* FtraceConfig::add_syscall_events() {
2873 std::string* _s = _internal_add_syscall_events();
2874 // @@protoc_insertion_point(field_add_mutable:perfetto.protos.FtraceConfig.syscall_events)
2875 return _s;
2876 }
_internal_syscall_events(int index)2877 inline const std::string& FtraceConfig::_internal_syscall_events(int index) const {
2878 return _impl_.syscall_events_.Get(index);
2879 }
syscall_events(int index)2880 inline const std::string& FtraceConfig::syscall_events(int index) const {
2881 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.syscall_events)
2882 return _internal_syscall_events(index);
2883 }
mutable_syscall_events(int index)2884 inline std::string* FtraceConfig::mutable_syscall_events(int index) {
2885 // @@protoc_insertion_point(field_mutable:perfetto.protos.FtraceConfig.syscall_events)
2886 return _impl_.syscall_events_.Mutable(index);
2887 }
set_syscall_events(int index,const std::string & value)2888 inline void FtraceConfig::set_syscall_events(int index, const std::string& value) {
2889 _impl_.syscall_events_.Mutable(index)->assign(value);
2890 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.syscall_events)
2891 }
set_syscall_events(int index,std::string && value)2892 inline void FtraceConfig::set_syscall_events(int index, std::string&& value) {
2893 _impl_.syscall_events_.Mutable(index)->assign(std::move(value));
2894 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.syscall_events)
2895 }
set_syscall_events(int index,const char * value)2896 inline void FtraceConfig::set_syscall_events(int index, const char* value) {
2897 GOOGLE_DCHECK(value != nullptr);
2898 _impl_.syscall_events_.Mutable(index)->assign(value);
2899 // @@protoc_insertion_point(field_set_char:perfetto.protos.FtraceConfig.syscall_events)
2900 }
set_syscall_events(int index,const char * value,size_t size)2901 inline void FtraceConfig::set_syscall_events(int index, const char* value, size_t size) {
2902 _impl_.syscall_events_.Mutable(index)->assign(
2903 reinterpret_cast<const char*>(value), size);
2904 // @@protoc_insertion_point(field_set_pointer:perfetto.protos.FtraceConfig.syscall_events)
2905 }
_internal_add_syscall_events()2906 inline std::string* FtraceConfig::_internal_add_syscall_events() {
2907 return _impl_.syscall_events_.Add();
2908 }
add_syscall_events(const std::string & value)2909 inline void FtraceConfig::add_syscall_events(const std::string& value) {
2910 _impl_.syscall_events_.Add()->assign(value);
2911 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.syscall_events)
2912 }
add_syscall_events(std::string && value)2913 inline void FtraceConfig::add_syscall_events(std::string&& value) {
2914 _impl_.syscall_events_.Add(std::move(value));
2915 // @@protoc_insertion_point(field_add:perfetto.protos.FtraceConfig.syscall_events)
2916 }
add_syscall_events(const char * value)2917 inline void FtraceConfig::add_syscall_events(const char* value) {
2918 GOOGLE_DCHECK(value != nullptr);
2919 _impl_.syscall_events_.Add()->assign(value);
2920 // @@protoc_insertion_point(field_add_char:perfetto.protos.FtraceConfig.syscall_events)
2921 }
add_syscall_events(const char * value,size_t size)2922 inline void FtraceConfig::add_syscall_events(const char* value, size_t size) {
2923 _impl_.syscall_events_.Add()->assign(reinterpret_cast<const char*>(value), size);
2924 // @@protoc_insertion_point(field_add_pointer:perfetto.protos.FtraceConfig.syscall_events)
2925 }
2926 inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
syscall_events()2927 FtraceConfig::syscall_events() const {
2928 // @@protoc_insertion_point(field_list:perfetto.protos.FtraceConfig.syscall_events)
2929 return _impl_.syscall_events_;
2930 }
2931 inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
mutable_syscall_events()2932 FtraceConfig::mutable_syscall_events() {
2933 // @@protoc_insertion_point(field_mutable_list:perfetto.protos.FtraceConfig.syscall_events)
2934 return &_impl_.syscall_events_;
2935 }
2936
2937 // optional bool enable_function_graph = 19;
_internal_has_enable_function_graph()2938 inline bool FtraceConfig::_internal_has_enable_function_graph() const {
2939 bool value = (_impl_._has_bits_[0] & 0x00000400u) != 0;
2940 return value;
2941 }
has_enable_function_graph()2942 inline bool FtraceConfig::has_enable_function_graph() const {
2943 return _internal_has_enable_function_graph();
2944 }
clear_enable_function_graph()2945 inline void FtraceConfig::clear_enable_function_graph() {
2946 _impl_.enable_function_graph_ = false;
2947 _impl_._has_bits_[0] &= ~0x00000400u;
2948 }
_internal_enable_function_graph()2949 inline bool FtraceConfig::_internal_enable_function_graph() const {
2950 return _impl_.enable_function_graph_;
2951 }
enable_function_graph()2952 inline bool FtraceConfig::enable_function_graph() const {
2953 // @@protoc_insertion_point(field_get:perfetto.protos.FtraceConfig.enable_function_graph)
2954 return _internal_enable_function_graph();
2955 }
_internal_set_enable_function_graph(bool value)2956 inline void FtraceConfig::_internal_set_enable_function_graph(bool value) {
2957 _impl_._has_bits_[0] |= 0x00000400u;
2958 _impl_.enable_function_graph_ = value;
2959 }
set_enable_function_graph(bool value)2960 inline void FtraceConfig::set_enable_function_graph(bool value) {
2961 _internal_set_enable_function_graph(value);
2962 // @@protoc_insertion_point(field_set:perfetto.protos.FtraceConfig.enable_function_graph)
2963 }
2964
2965 // repeated string function_filters = 20;
_internal_function_filters_size()2966 inline int FtraceConfig::_internal_function_filters_size() const {
2967 return _impl_.function_filters_.size();
2968 }
function_filters_size()2969