1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/config/track_event/track_event_config.proto
3
4 #include "protos/perfetto/config/track_event/track_event_config.pb.h"
5
6 #include <algorithm>
7 #include <cstdint>
8
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15
16 PROTOBUF_PRAGMA_INIT_SEG
17
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20
21 namespace perfetto {
22 namespace protos {
TrackEventConfig(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR TrackEventConfig::TrackEventConfig(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.disabled_categories_)*/{}
28 , /*decltype(_impl_.enabled_categories_)*/{}
29 , /*decltype(_impl_.disabled_tags_)*/{}
30 , /*decltype(_impl_.enabled_tags_)*/{}
31 , /*decltype(_impl_.timestamp_unit_multiplier_)*/::uint64_t{0u}
32 , /*decltype(_impl_.disable_incremental_timestamps_)*/false
33 , /*decltype(_impl_.filter_debug_annotations_)*/false
34 , /*decltype(_impl_.enable_thread_time_sampling_)*/false
35 , /*decltype(_impl_.filter_dynamic_event_names_)*/false} {}
36 struct TrackEventConfigDefaultTypeInternal {
TrackEventConfigDefaultTypeInternalperfetto::protos::TrackEventConfigDefaultTypeInternal37 PROTOBUF_CONSTEXPR TrackEventConfigDefaultTypeInternal()
38 : _instance(::_pbi::ConstantInitialized{}) {}
~TrackEventConfigDefaultTypeInternalperfetto::protos::TrackEventConfigDefaultTypeInternal39 ~TrackEventConfigDefaultTypeInternal() {}
40 union { // NOLINT(misc-non-private-member-variables-in-classes)
41 TrackEventConfig _instance;
42 };
43 };
44 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TrackEventConfigDefaultTypeInternal _TrackEventConfig_default_instance_;
45 } // namespace protos
46 } // namespace perfetto
47 namespace perfetto {
48 namespace protos {
49
50 // ===================================================================
51
52 class TrackEventConfig::_Internal {
53 public:
54 using HasBits = decltype(std::declval<TrackEventConfig>()._impl_._has_bits_);
set_has_disable_incremental_timestamps(HasBits * has_bits)55 static void set_has_disable_incremental_timestamps(HasBits* has_bits) {
56 (*has_bits)[0] |= 2u;
57 }
set_has_timestamp_unit_multiplier(HasBits * has_bits)58 static void set_has_timestamp_unit_multiplier(HasBits* has_bits) {
59 (*has_bits)[0] |= 1u;
60 }
set_has_filter_debug_annotations(HasBits * has_bits)61 static void set_has_filter_debug_annotations(HasBits* has_bits) {
62 (*has_bits)[0] |= 4u;
63 }
set_has_enable_thread_time_sampling(HasBits * has_bits)64 static void set_has_enable_thread_time_sampling(HasBits* has_bits) {
65 (*has_bits)[0] |= 8u;
66 }
set_has_filter_dynamic_event_names(HasBits * has_bits)67 static void set_has_filter_dynamic_event_names(HasBits* has_bits) {
68 (*has_bits)[0] |= 16u;
69 }
70 };
71
TrackEventConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)72 TrackEventConfig::TrackEventConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
73 bool is_message_owned)
74 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
75 SharedCtor(arena, is_message_owned);
76 // @@protoc_insertion_point(arena_constructor:perfetto.protos.TrackEventConfig)
77 }
TrackEventConfig(const TrackEventConfig & from)78 TrackEventConfig::TrackEventConfig(const TrackEventConfig& from)
79 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
80 TrackEventConfig* const _this = this; (void)_this;
81 new (&_impl_) Impl_{
82 decltype(_impl_._has_bits_){from._impl_._has_bits_}
83 , /*decltype(_impl_._cached_size_)*/{}
84 , decltype(_impl_.disabled_categories_){from._impl_.disabled_categories_}
85 , decltype(_impl_.enabled_categories_){from._impl_.enabled_categories_}
86 , decltype(_impl_.disabled_tags_){from._impl_.disabled_tags_}
87 , decltype(_impl_.enabled_tags_){from._impl_.enabled_tags_}
88 , decltype(_impl_.timestamp_unit_multiplier_){}
89 , decltype(_impl_.disable_incremental_timestamps_){}
90 , decltype(_impl_.filter_debug_annotations_){}
91 , decltype(_impl_.enable_thread_time_sampling_){}
92 , decltype(_impl_.filter_dynamic_event_names_){}};
93
94 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
95 ::memcpy(&_impl_.timestamp_unit_multiplier_, &from._impl_.timestamp_unit_multiplier_,
96 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.filter_dynamic_event_names_) -
97 reinterpret_cast<char*>(&_impl_.timestamp_unit_multiplier_)) + sizeof(_impl_.filter_dynamic_event_names_));
98 // @@protoc_insertion_point(copy_constructor:perfetto.protos.TrackEventConfig)
99 }
100
SharedCtor(::_pb::Arena * arena,bool is_message_owned)101 inline void TrackEventConfig::SharedCtor(
102 ::_pb::Arena* arena, bool is_message_owned) {
103 (void)arena;
104 (void)is_message_owned;
105 new (&_impl_) Impl_{
106 decltype(_impl_._has_bits_){}
107 , /*decltype(_impl_._cached_size_)*/{}
108 , decltype(_impl_.disabled_categories_){arena}
109 , decltype(_impl_.enabled_categories_){arena}
110 , decltype(_impl_.disabled_tags_){arena}
111 , decltype(_impl_.enabled_tags_){arena}
112 , decltype(_impl_.timestamp_unit_multiplier_){::uint64_t{0u}}
113 , decltype(_impl_.disable_incremental_timestamps_){false}
114 , decltype(_impl_.filter_debug_annotations_){false}
115 , decltype(_impl_.enable_thread_time_sampling_){false}
116 , decltype(_impl_.filter_dynamic_event_names_){false}
117 };
118 }
119
~TrackEventConfig()120 TrackEventConfig::~TrackEventConfig() {
121 // @@protoc_insertion_point(destructor:perfetto.protos.TrackEventConfig)
122 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
123 (void)arena;
124 return;
125 }
126 SharedDtor();
127 }
128
SharedDtor()129 inline void TrackEventConfig::SharedDtor() {
130 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
131 _impl_.disabled_categories_.~RepeatedPtrField();
132 _impl_.enabled_categories_.~RepeatedPtrField();
133 _impl_.disabled_tags_.~RepeatedPtrField();
134 _impl_.enabled_tags_.~RepeatedPtrField();
135 }
136
SetCachedSize(int size) const137 void TrackEventConfig::SetCachedSize(int size) const {
138 _impl_._cached_size_.Set(size);
139 }
140
Clear()141 void TrackEventConfig::Clear() {
142 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TrackEventConfig)
143 ::uint32_t cached_has_bits = 0;
144 // Prevent compiler warnings about cached_has_bits being unused
145 (void) cached_has_bits;
146
147 _impl_.disabled_categories_.Clear();
148 _impl_.enabled_categories_.Clear();
149 _impl_.disabled_tags_.Clear();
150 _impl_.enabled_tags_.Clear();
151 cached_has_bits = _impl_._has_bits_[0];
152 if (cached_has_bits & 0x0000001fu) {
153 ::memset(&_impl_.timestamp_unit_multiplier_, 0, static_cast<size_t>(
154 reinterpret_cast<char*>(&_impl_.filter_dynamic_event_names_) -
155 reinterpret_cast<char*>(&_impl_.timestamp_unit_multiplier_)) + sizeof(_impl_.filter_dynamic_event_names_));
156 }
157 _impl_._has_bits_.Clear();
158 _internal_metadata_.Clear<std::string>();
159 }
160
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)161 const char* TrackEventConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
162 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
163 _Internal::HasBits has_bits{};
164 while (!ctx->Done(&ptr)) {
165 ::uint32_t tag;
166 ptr = ::_pbi::ReadTag(ptr, &tag);
167 switch (tag >> 3) {
168 // repeated string disabled_categories = 1;
169 case 1:
170 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
171 ptr -= 1;
172 do {
173 ptr += 1;
174 auto str = _internal_add_disabled_categories();
175 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
176 CHK_(ptr);
177 if (!ctx->DataAvailable(ptr)) break;
178 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
179 } else {
180 goto handle_unusual;
181 }
182 continue;
183 // repeated string enabled_categories = 2;
184 case 2:
185 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
186 ptr -= 1;
187 do {
188 ptr += 1;
189 auto str = _internal_add_enabled_categories();
190 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
191 CHK_(ptr);
192 if (!ctx->DataAvailable(ptr)) break;
193 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
194 } else {
195 goto handle_unusual;
196 }
197 continue;
198 // repeated string disabled_tags = 3;
199 case 3:
200 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
201 ptr -= 1;
202 do {
203 ptr += 1;
204 auto str = _internal_add_disabled_tags();
205 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
206 CHK_(ptr);
207 if (!ctx->DataAvailable(ptr)) break;
208 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
209 } else {
210 goto handle_unusual;
211 }
212 continue;
213 // repeated string enabled_tags = 4;
214 case 4:
215 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
216 ptr -= 1;
217 do {
218 ptr += 1;
219 auto str = _internal_add_enabled_tags();
220 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
221 CHK_(ptr);
222 if (!ctx->DataAvailable(ptr)) break;
223 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<34>(ptr));
224 } else {
225 goto handle_unusual;
226 }
227 continue;
228 // optional bool disable_incremental_timestamps = 5;
229 case 5:
230 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
231 _Internal::set_has_disable_incremental_timestamps(&has_bits);
232 _impl_.disable_incremental_timestamps_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
233 CHK_(ptr);
234 } else {
235 goto handle_unusual;
236 }
237 continue;
238 // optional uint64 timestamp_unit_multiplier = 6;
239 case 6:
240 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
241 _Internal::set_has_timestamp_unit_multiplier(&has_bits);
242 _impl_.timestamp_unit_multiplier_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
243 CHK_(ptr);
244 } else {
245 goto handle_unusual;
246 }
247 continue;
248 // optional bool filter_debug_annotations = 7;
249 case 7:
250 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
251 _Internal::set_has_filter_debug_annotations(&has_bits);
252 _impl_.filter_debug_annotations_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
253 CHK_(ptr);
254 } else {
255 goto handle_unusual;
256 }
257 continue;
258 // optional bool enable_thread_time_sampling = 8;
259 case 8:
260 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
261 _Internal::set_has_enable_thread_time_sampling(&has_bits);
262 _impl_.enable_thread_time_sampling_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
263 CHK_(ptr);
264 } else {
265 goto handle_unusual;
266 }
267 continue;
268 // optional bool filter_dynamic_event_names = 9;
269 case 9:
270 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
271 _Internal::set_has_filter_dynamic_event_names(&has_bits);
272 _impl_.filter_dynamic_event_names_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
273 CHK_(ptr);
274 } else {
275 goto handle_unusual;
276 }
277 continue;
278 default:
279 goto handle_unusual;
280 } // switch
281 handle_unusual:
282 if ((tag == 0) || ((tag & 7) == 4)) {
283 CHK_(ptr);
284 ctx->SetLastTag(tag);
285 goto message_done;
286 }
287 ptr = UnknownFieldParse(
288 tag,
289 _internal_metadata_.mutable_unknown_fields<std::string>(),
290 ptr, ctx);
291 CHK_(ptr != nullptr);
292 } // while
293 message_done:
294 _impl_._has_bits_.Or(has_bits);
295 return ptr;
296 failure:
297 ptr = nullptr;
298 goto message_done;
299 #undef CHK_
300 }
301
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const302 ::uint8_t* TrackEventConfig::_InternalSerialize(
303 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
304 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TrackEventConfig)
305 ::uint32_t cached_has_bits = 0;
306 (void) cached_has_bits;
307
308 // repeated string disabled_categories = 1;
309 for (int i = 0, n = this->_internal_disabled_categories_size(); i < n; i++) {
310 const auto& s = this->_internal_disabled_categories(i);
311 target = stream->WriteString(1, s, target);
312 }
313
314 // repeated string enabled_categories = 2;
315 for (int i = 0, n = this->_internal_enabled_categories_size(); i < n; i++) {
316 const auto& s = this->_internal_enabled_categories(i);
317 target = stream->WriteString(2, s, target);
318 }
319
320 // repeated string disabled_tags = 3;
321 for (int i = 0, n = this->_internal_disabled_tags_size(); i < n; i++) {
322 const auto& s = this->_internal_disabled_tags(i);
323 target = stream->WriteString(3, s, target);
324 }
325
326 // repeated string enabled_tags = 4;
327 for (int i = 0, n = this->_internal_enabled_tags_size(); i < n; i++) {
328 const auto& s = this->_internal_enabled_tags(i);
329 target = stream->WriteString(4, s, target);
330 }
331
332 cached_has_bits = _impl_._has_bits_[0];
333 // optional bool disable_incremental_timestamps = 5;
334 if (cached_has_bits & 0x00000002u) {
335 target = stream->EnsureSpace(target);
336 target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_disable_incremental_timestamps(), target);
337 }
338
339 // optional uint64 timestamp_unit_multiplier = 6;
340 if (cached_has_bits & 0x00000001u) {
341 target = stream->EnsureSpace(target);
342 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_timestamp_unit_multiplier(), target);
343 }
344
345 // optional bool filter_debug_annotations = 7;
346 if (cached_has_bits & 0x00000004u) {
347 target = stream->EnsureSpace(target);
348 target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_filter_debug_annotations(), target);
349 }
350
351 // optional bool enable_thread_time_sampling = 8;
352 if (cached_has_bits & 0x00000008u) {
353 target = stream->EnsureSpace(target);
354 target = ::_pbi::WireFormatLite::WriteBoolToArray(8, this->_internal_enable_thread_time_sampling(), target);
355 }
356
357 // optional bool filter_dynamic_event_names = 9;
358 if (cached_has_bits & 0x00000010u) {
359 target = stream->EnsureSpace(target);
360 target = ::_pbi::WireFormatLite::WriteBoolToArray(9, this->_internal_filter_dynamic_event_names(), target);
361 }
362
363 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
364 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
365 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
366 }
367 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TrackEventConfig)
368 return target;
369 }
370
ByteSizeLong() const371 size_t TrackEventConfig::ByteSizeLong() const {
372 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TrackEventConfig)
373 size_t total_size = 0;
374
375 ::uint32_t cached_has_bits = 0;
376 // Prevent compiler warnings about cached_has_bits being unused
377 (void) cached_has_bits;
378
379 // repeated string disabled_categories = 1;
380 total_size += 1 *
381 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.disabled_categories_.size());
382 for (int i = 0, n = _impl_.disabled_categories_.size(); i < n; i++) {
383 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
384 _impl_.disabled_categories_.Get(i));
385 }
386
387 // repeated string enabled_categories = 2;
388 total_size += 1 *
389 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.enabled_categories_.size());
390 for (int i = 0, n = _impl_.enabled_categories_.size(); i < n; i++) {
391 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
392 _impl_.enabled_categories_.Get(i));
393 }
394
395 // repeated string disabled_tags = 3;
396 total_size += 1 *
397 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.disabled_tags_.size());
398 for (int i = 0, n = _impl_.disabled_tags_.size(); i < n; i++) {
399 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
400 _impl_.disabled_tags_.Get(i));
401 }
402
403 // repeated string enabled_tags = 4;
404 total_size += 1 *
405 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.enabled_tags_.size());
406 for (int i = 0, n = _impl_.enabled_tags_.size(); i < n; i++) {
407 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
408 _impl_.enabled_tags_.Get(i));
409 }
410
411 cached_has_bits = _impl_._has_bits_[0];
412 if (cached_has_bits & 0x0000001fu) {
413 // optional uint64 timestamp_unit_multiplier = 6;
414 if (cached_has_bits & 0x00000001u) {
415 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp_unit_multiplier());
416 }
417
418 // optional bool disable_incremental_timestamps = 5;
419 if (cached_has_bits & 0x00000002u) {
420 total_size += 1 + 1;
421 }
422
423 // optional bool filter_debug_annotations = 7;
424 if (cached_has_bits & 0x00000004u) {
425 total_size += 1 + 1;
426 }
427
428 // optional bool enable_thread_time_sampling = 8;
429 if (cached_has_bits & 0x00000008u) {
430 total_size += 1 + 1;
431 }
432
433 // optional bool filter_dynamic_event_names = 9;
434 if (cached_has_bits & 0x00000010u) {
435 total_size += 1 + 1;
436 }
437
438 }
439 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
440 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
441 }
442 int cached_size = ::_pbi::ToCachedSize(total_size);
443 SetCachedSize(cached_size);
444 return total_size;
445 }
446
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)447 void TrackEventConfig::CheckTypeAndMergeFrom(
448 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
449 MergeFrom(*::_pbi::DownCast<const TrackEventConfig*>(
450 &from));
451 }
452
MergeFrom(const TrackEventConfig & from)453 void TrackEventConfig::MergeFrom(const TrackEventConfig& from) {
454 TrackEventConfig* const _this = this;
455 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TrackEventConfig)
456 GOOGLE_DCHECK_NE(&from, _this);
457 ::uint32_t cached_has_bits = 0;
458 (void) cached_has_bits;
459
460 _this->_impl_.disabled_categories_.MergeFrom(from._impl_.disabled_categories_);
461 _this->_impl_.enabled_categories_.MergeFrom(from._impl_.enabled_categories_);
462 _this->_impl_.disabled_tags_.MergeFrom(from._impl_.disabled_tags_);
463 _this->_impl_.enabled_tags_.MergeFrom(from._impl_.enabled_tags_);
464 cached_has_bits = from._impl_._has_bits_[0];
465 if (cached_has_bits & 0x0000001fu) {
466 if (cached_has_bits & 0x00000001u) {
467 _this->_impl_.timestamp_unit_multiplier_ = from._impl_.timestamp_unit_multiplier_;
468 }
469 if (cached_has_bits & 0x00000002u) {
470 _this->_impl_.disable_incremental_timestamps_ = from._impl_.disable_incremental_timestamps_;
471 }
472 if (cached_has_bits & 0x00000004u) {
473 _this->_impl_.filter_debug_annotations_ = from._impl_.filter_debug_annotations_;
474 }
475 if (cached_has_bits & 0x00000008u) {
476 _this->_impl_.enable_thread_time_sampling_ = from._impl_.enable_thread_time_sampling_;
477 }
478 if (cached_has_bits & 0x00000010u) {
479 _this->_impl_.filter_dynamic_event_names_ = from._impl_.filter_dynamic_event_names_;
480 }
481 _this->_impl_._has_bits_[0] |= cached_has_bits;
482 }
483 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
484 }
485
CopyFrom(const TrackEventConfig & from)486 void TrackEventConfig::CopyFrom(const TrackEventConfig& from) {
487 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TrackEventConfig)
488 if (&from == this) return;
489 Clear();
490 MergeFrom(from);
491 }
492
IsInitialized() const493 bool TrackEventConfig::IsInitialized() const {
494 return true;
495 }
496
InternalSwap(TrackEventConfig * other)497 void TrackEventConfig::InternalSwap(TrackEventConfig* other) {
498 using std::swap;
499 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
500 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
501 _impl_.disabled_categories_.InternalSwap(&other->_impl_.disabled_categories_);
502 _impl_.enabled_categories_.InternalSwap(&other->_impl_.enabled_categories_);
503 _impl_.disabled_tags_.InternalSwap(&other->_impl_.disabled_tags_);
504 _impl_.enabled_tags_.InternalSwap(&other->_impl_.enabled_tags_);
505 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
506 PROTOBUF_FIELD_OFFSET(TrackEventConfig, _impl_.filter_dynamic_event_names_)
507 + sizeof(TrackEventConfig::_impl_.filter_dynamic_event_names_) // NOLINT
508 - PROTOBUF_FIELD_OFFSET(TrackEventConfig, _impl_.timestamp_unit_multiplier_)>(
509 reinterpret_cast<char*>(&_impl_.timestamp_unit_multiplier_),
510 reinterpret_cast<char*>(&other->_impl_.timestamp_unit_multiplier_));
511 }
512
GetTypeName() const513 std::string TrackEventConfig::GetTypeName() const {
514 return "perfetto.protos.TrackEventConfig";
515 }
516
517
518 // @@protoc_insertion_point(namespace_scope)
519 } // namespace protos
520 } // namespace perfetto
521 PROTOBUF_NAMESPACE_OPEN
522 template<> PROTOBUF_NOINLINE ::perfetto::protos::TrackEventConfig*
CreateMaybeMessage(Arena * arena)523 Arena::CreateMaybeMessage< ::perfetto::protos::TrackEventConfig >(Arena* arena) {
524 return Arena::CreateMessageInternal< ::perfetto::protos::TrackEventConfig >(arena);
525 }
526 PROTOBUF_NAMESPACE_CLOSE
527
528 // @@protoc_insertion_point(global_scope)
529 #include <google/protobuf/port_undef.inc>
530