1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/track_event/counter_descriptor.proto
3
4 #include "protos/perfetto/trace/track_event/counter_descriptor.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 {
CounterDescriptor(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR CounterDescriptor::CounterDescriptor(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.categories_)*/{}
28 , /*decltype(_impl_.unit_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29 , /*decltype(_impl_.type_)*/0
30 , /*decltype(_impl_.unit_)*/0
31 , /*decltype(_impl_.unit_multiplier_)*/::int64_t{0}
32 , /*decltype(_impl_.is_incremental_)*/false} {}
33 struct CounterDescriptorDefaultTypeInternal {
CounterDescriptorDefaultTypeInternalperfetto::protos::CounterDescriptorDefaultTypeInternal34 PROTOBUF_CONSTEXPR CounterDescriptorDefaultTypeInternal()
35 : _instance(::_pbi::ConstantInitialized{}) {}
~CounterDescriptorDefaultTypeInternalperfetto::protos::CounterDescriptorDefaultTypeInternal36 ~CounterDescriptorDefaultTypeInternal() {}
37 union { // NOLINT(misc-non-private-member-variables-in-classes)
38 CounterDescriptor _instance;
39 };
40 };
41 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CounterDescriptorDefaultTypeInternal _CounterDescriptor_default_instance_;
42 } // namespace protos
43 } // namespace perfetto
44 namespace perfetto {
45 namespace protos {
CounterDescriptor_BuiltinCounterType_IsValid(int value)46 bool CounterDescriptor_BuiltinCounterType_IsValid(int value) {
47 switch (value) {
48 case 0:
49 case 1:
50 case 2:
51 return true;
52 default:
53 return false;
54 }
55 }
56
57 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CounterDescriptor_BuiltinCounterType_strings[3] = {};
58
59 static const char CounterDescriptor_BuiltinCounterType_names[] =
60 "COUNTER_THREAD_INSTRUCTION_COUNT"
61 "COUNTER_THREAD_TIME_NS"
62 "COUNTER_UNSPECIFIED";
63
64 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CounterDescriptor_BuiltinCounterType_entries[] = {
65 { {CounterDescriptor_BuiltinCounterType_names + 0, 32}, 2 },
66 { {CounterDescriptor_BuiltinCounterType_names + 32, 22}, 1 },
67 { {CounterDescriptor_BuiltinCounterType_names + 54, 19}, 0 },
68 };
69
70 static const int CounterDescriptor_BuiltinCounterType_entries_by_number[] = {
71 2, // 0 -> COUNTER_UNSPECIFIED
72 1, // 1 -> COUNTER_THREAD_TIME_NS
73 0, // 2 -> COUNTER_THREAD_INSTRUCTION_COUNT
74 };
75
CounterDescriptor_BuiltinCounterType_Name(CounterDescriptor_BuiltinCounterType value)76 const std::string& CounterDescriptor_BuiltinCounterType_Name(
77 CounterDescriptor_BuiltinCounterType value) {
78 static const bool dummy =
79 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
80 CounterDescriptor_BuiltinCounterType_entries,
81 CounterDescriptor_BuiltinCounterType_entries_by_number,
82 3, CounterDescriptor_BuiltinCounterType_strings);
83 (void) dummy;
84 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
85 CounterDescriptor_BuiltinCounterType_entries,
86 CounterDescriptor_BuiltinCounterType_entries_by_number,
87 3, value);
88 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
89 CounterDescriptor_BuiltinCounterType_strings[idx].get();
90 }
CounterDescriptor_BuiltinCounterType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,CounterDescriptor_BuiltinCounterType * value)91 bool CounterDescriptor_BuiltinCounterType_Parse(
92 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CounterDescriptor_BuiltinCounterType* value) {
93 int int_value;
94 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
95 CounterDescriptor_BuiltinCounterType_entries, 3, name, &int_value);
96 if (success) {
97 *value = static_cast<CounterDescriptor_BuiltinCounterType>(int_value);
98 }
99 return success;
100 }
101 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
102 constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor::COUNTER_UNSPECIFIED;
103 constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor::COUNTER_THREAD_TIME_NS;
104 constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor::COUNTER_THREAD_INSTRUCTION_COUNT;
105 constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor::BuiltinCounterType_MIN;
106 constexpr CounterDescriptor_BuiltinCounterType CounterDescriptor::BuiltinCounterType_MAX;
107 constexpr int CounterDescriptor::BuiltinCounterType_ARRAYSIZE;
108 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
CounterDescriptor_Unit_IsValid(int value)109 bool CounterDescriptor_Unit_IsValid(int value) {
110 switch (value) {
111 case 0:
112 case 1:
113 case 2:
114 case 3:
115 return true;
116 default:
117 return false;
118 }
119 }
120
121 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> CounterDescriptor_Unit_strings[4] = {};
122
123 static const char CounterDescriptor_Unit_names[] =
124 "UNIT_COUNT"
125 "UNIT_SIZE_BYTES"
126 "UNIT_TIME_NS"
127 "UNIT_UNSPECIFIED";
128
129 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry CounterDescriptor_Unit_entries[] = {
130 { {CounterDescriptor_Unit_names + 0, 10}, 2 },
131 { {CounterDescriptor_Unit_names + 10, 15}, 3 },
132 { {CounterDescriptor_Unit_names + 25, 12}, 1 },
133 { {CounterDescriptor_Unit_names + 37, 16}, 0 },
134 };
135
136 static const int CounterDescriptor_Unit_entries_by_number[] = {
137 3, // 0 -> UNIT_UNSPECIFIED
138 2, // 1 -> UNIT_TIME_NS
139 0, // 2 -> UNIT_COUNT
140 1, // 3 -> UNIT_SIZE_BYTES
141 };
142
CounterDescriptor_Unit_Name(CounterDescriptor_Unit value)143 const std::string& CounterDescriptor_Unit_Name(
144 CounterDescriptor_Unit value) {
145 static const bool dummy =
146 ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
147 CounterDescriptor_Unit_entries,
148 CounterDescriptor_Unit_entries_by_number,
149 4, CounterDescriptor_Unit_strings);
150 (void) dummy;
151 int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
152 CounterDescriptor_Unit_entries,
153 CounterDescriptor_Unit_entries_by_number,
154 4, value);
155 return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
156 CounterDescriptor_Unit_strings[idx].get();
157 }
CounterDescriptor_Unit_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,CounterDescriptor_Unit * value)158 bool CounterDescriptor_Unit_Parse(
159 ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CounterDescriptor_Unit* value) {
160 int int_value;
161 bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
162 CounterDescriptor_Unit_entries, 4, name, &int_value);
163 if (success) {
164 *value = static_cast<CounterDescriptor_Unit>(int_value);
165 }
166 return success;
167 }
168 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
169 constexpr CounterDescriptor_Unit CounterDescriptor::UNIT_UNSPECIFIED;
170 constexpr CounterDescriptor_Unit CounterDescriptor::UNIT_TIME_NS;
171 constexpr CounterDescriptor_Unit CounterDescriptor::UNIT_COUNT;
172 constexpr CounterDescriptor_Unit CounterDescriptor::UNIT_SIZE_BYTES;
173 constexpr CounterDescriptor_Unit CounterDescriptor::Unit_MIN;
174 constexpr CounterDescriptor_Unit CounterDescriptor::Unit_MAX;
175 constexpr int CounterDescriptor::Unit_ARRAYSIZE;
176 #endif // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
177
178 // ===================================================================
179
180 class CounterDescriptor::_Internal {
181 public:
182 using HasBits = decltype(std::declval<CounterDescriptor>()._impl_._has_bits_);
set_has_type(HasBits * has_bits)183 static void set_has_type(HasBits* has_bits) {
184 (*has_bits)[0] |= 2u;
185 }
set_has_unit(HasBits * has_bits)186 static void set_has_unit(HasBits* has_bits) {
187 (*has_bits)[0] |= 4u;
188 }
set_has_unit_name(HasBits * has_bits)189 static void set_has_unit_name(HasBits* has_bits) {
190 (*has_bits)[0] |= 1u;
191 }
set_has_unit_multiplier(HasBits * has_bits)192 static void set_has_unit_multiplier(HasBits* has_bits) {
193 (*has_bits)[0] |= 8u;
194 }
set_has_is_incremental(HasBits * has_bits)195 static void set_has_is_incremental(HasBits* has_bits) {
196 (*has_bits)[0] |= 16u;
197 }
198 };
199
CounterDescriptor(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)200 CounterDescriptor::CounterDescriptor(::PROTOBUF_NAMESPACE_ID::Arena* arena,
201 bool is_message_owned)
202 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
203 SharedCtor(arena, is_message_owned);
204 // @@protoc_insertion_point(arena_constructor:perfetto.protos.CounterDescriptor)
205 }
CounterDescriptor(const CounterDescriptor & from)206 CounterDescriptor::CounterDescriptor(const CounterDescriptor& from)
207 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
208 CounterDescriptor* const _this = this; (void)_this;
209 new (&_impl_) Impl_{
210 decltype(_impl_._has_bits_){from._impl_._has_bits_}
211 , /*decltype(_impl_._cached_size_)*/{}
212 , decltype(_impl_.categories_){from._impl_.categories_}
213 , decltype(_impl_.unit_name_){}
214 , decltype(_impl_.type_){}
215 , decltype(_impl_.unit_){}
216 , decltype(_impl_.unit_multiplier_){}
217 , decltype(_impl_.is_incremental_){}};
218
219 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
220 _impl_.unit_name_.InitDefault();
221 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
222 _impl_.unit_name_.Set("", GetArenaForAllocation());
223 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
224 if (from._internal_has_unit_name()) {
225 _this->_impl_.unit_name_.Set(from._internal_unit_name(),
226 _this->GetArenaForAllocation());
227 }
228 ::memcpy(&_impl_.type_, &from._impl_.type_,
229 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_incremental_) -
230 reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.is_incremental_));
231 // @@protoc_insertion_point(copy_constructor:perfetto.protos.CounterDescriptor)
232 }
233
SharedCtor(::_pb::Arena * arena,bool is_message_owned)234 inline void CounterDescriptor::SharedCtor(
235 ::_pb::Arena* arena, bool is_message_owned) {
236 (void)arena;
237 (void)is_message_owned;
238 new (&_impl_) Impl_{
239 decltype(_impl_._has_bits_){}
240 , /*decltype(_impl_._cached_size_)*/{}
241 , decltype(_impl_.categories_){arena}
242 , decltype(_impl_.unit_name_){}
243 , decltype(_impl_.type_){0}
244 , decltype(_impl_.unit_){0}
245 , decltype(_impl_.unit_multiplier_){::int64_t{0}}
246 , decltype(_impl_.is_incremental_){false}
247 };
248 _impl_.unit_name_.InitDefault();
249 #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
250 _impl_.unit_name_.Set("", GetArenaForAllocation());
251 #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
252 }
253
~CounterDescriptor()254 CounterDescriptor::~CounterDescriptor() {
255 // @@protoc_insertion_point(destructor:perfetto.protos.CounterDescriptor)
256 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
257 (void)arena;
258 return;
259 }
260 SharedDtor();
261 }
262
SharedDtor()263 inline void CounterDescriptor::SharedDtor() {
264 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
265 _impl_.categories_.~RepeatedPtrField();
266 _impl_.unit_name_.Destroy();
267 }
268
SetCachedSize(int size) const269 void CounterDescriptor::SetCachedSize(int size) const {
270 _impl_._cached_size_.Set(size);
271 }
272
Clear()273 void CounterDescriptor::Clear() {
274 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CounterDescriptor)
275 ::uint32_t cached_has_bits = 0;
276 // Prevent compiler warnings about cached_has_bits being unused
277 (void) cached_has_bits;
278
279 _impl_.categories_.Clear();
280 cached_has_bits = _impl_._has_bits_[0];
281 if (cached_has_bits & 0x00000001u) {
282 _impl_.unit_name_.ClearNonDefaultToEmpty();
283 }
284 if (cached_has_bits & 0x0000001eu) {
285 ::memset(&_impl_.type_, 0, static_cast<size_t>(
286 reinterpret_cast<char*>(&_impl_.is_incremental_) -
287 reinterpret_cast<char*>(&_impl_.type_)) + sizeof(_impl_.is_incremental_));
288 }
289 _impl_._has_bits_.Clear();
290 _internal_metadata_.Clear<std::string>();
291 }
292
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)293 const char* CounterDescriptor::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
294 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
295 _Internal::HasBits has_bits{};
296 while (!ctx->Done(&ptr)) {
297 ::uint32_t tag;
298 ptr = ::_pbi::ReadTag(ptr, &tag);
299 switch (tag >> 3) {
300 // optional .perfetto.protos.CounterDescriptor.BuiltinCounterType type = 1;
301 case 1:
302 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
303 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
304 CHK_(ptr);
305 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::CounterDescriptor_BuiltinCounterType_IsValid(val))) {
306 _internal_set_type(static_cast<::perfetto::protos::CounterDescriptor_BuiltinCounterType>(val));
307 } else {
308 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
309 }
310 } else {
311 goto handle_unusual;
312 }
313 continue;
314 // repeated string categories = 2;
315 case 2:
316 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
317 ptr -= 1;
318 do {
319 ptr += 1;
320 auto str = _internal_add_categories();
321 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
322 CHK_(ptr);
323 if (!ctx->DataAvailable(ptr)) break;
324 } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
325 } else {
326 goto handle_unusual;
327 }
328 continue;
329 // optional .perfetto.protos.CounterDescriptor.Unit unit = 3;
330 case 3:
331 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
332 ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
333 CHK_(ptr);
334 if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::CounterDescriptor_Unit_IsValid(val))) {
335 _internal_set_unit(static_cast<::perfetto::protos::CounterDescriptor_Unit>(val));
336 } else {
337 ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
338 }
339 } else {
340 goto handle_unusual;
341 }
342 continue;
343 // optional int64 unit_multiplier = 4;
344 case 4:
345 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
346 _Internal::set_has_unit_multiplier(&has_bits);
347 _impl_.unit_multiplier_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
348 CHK_(ptr);
349 } else {
350 goto handle_unusual;
351 }
352 continue;
353 // optional bool is_incremental = 5;
354 case 5:
355 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
356 _Internal::set_has_is_incremental(&has_bits);
357 _impl_.is_incremental_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
358 CHK_(ptr);
359 } else {
360 goto handle_unusual;
361 }
362 continue;
363 // optional string unit_name = 6;
364 case 6:
365 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
366 auto str = _internal_mutable_unit_name();
367 ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
368 CHK_(ptr);
369 } else {
370 goto handle_unusual;
371 }
372 continue;
373 default:
374 goto handle_unusual;
375 } // switch
376 handle_unusual:
377 if ((tag == 0) || ((tag & 7) == 4)) {
378 CHK_(ptr);
379 ctx->SetLastTag(tag);
380 goto message_done;
381 }
382 ptr = UnknownFieldParse(
383 tag,
384 _internal_metadata_.mutable_unknown_fields<std::string>(),
385 ptr, ctx);
386 CHK_(ptr != nullptr);
387 } // while
388 message_done:
389 _impl_._has_bits_.Or(has_bits);
390 return ptr;
391 failure:
392 ptr = nullptr;
393 goto message_done;
394 #undef CHK_
395 }
396
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const397 ::uint8_t* CounterDescriptor::_InternalSerialize(
398 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
399 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CounterDescriptor)
400 ::uint32_t cached_has_bits = 0;
401 (void) cached_has_bits;
402
403 cached_has_bits = _impl_._has_bits_[0];
404 // optional .perfetto.protos.CounterDescriptor.BuiltinCounterType type = 1;
405 if (cached_has_bits & 0x00000002u) {
406 target = stream->EnsureSpace(target);
407 target = ::_pbi::WireFormatLite::WriteEnumToArray(
408 1, this->_internal_type(), target);
409 }
410
411 // repeated string categories = 2;
412 for (int i = 0, n = this->_internal_categories_size(); i < n; i++) {
413 const auto& s = this->_internal_categories(i);
414 target = stream->WriteString(2, s, target);
415 }
416
417 // optional .perfetto.protos.CounterDescriptor.Unit unit = 3;
418 if (cached_has_bits & 0x00000004u) {
419 target = stream->EnsureSpace(target);
420 target = ::_pbi::WireFormatLite::WriteEnumToArray(
421 3, this->_internal_unit(), target);
422 }
423
424 // optional int64 unit_multiplier = 4;
425 if (cached_has_bits & 0x00000008u) {
426 target = stream->EnsureSpace(target);
427 target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_unit_multiplier(), target);
428 }
429
430 // optional bool is_incremental = 5;
431 if (cached_has_bits & 0x00000010u) {
432 target = stream->EnsureSpace(target);
433 target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_is_incremental(), target);
434 }
435
436 // optional string unit_name = 6;
437 if (cached_has_bits & 0x00000001u) {
438 target = stream->WriteStringMaybeAliased(
439 6, this->_internal_unit_name(), target);
440 }
441
442 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
443 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
444 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
445 }
446 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CounterDescriptor)
447 return target;
448 }
449
ByteSizeLong() const450 size_t CounterDescriptor::ByteSizeLong() const {
451 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CounterDescriptor)
452 size_t total_size = 0;
453
454 ::uint32_t cached_has_bits = 0;
455 // Prevent compiler warnings about cached_has_bits being unused
456 (void) cached_has_bits;
457
458 // repeated string categories = 2;
459 total_size += 1 *
460 ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.categories_.size());
461 for (int i = 0, n = _impl_.categories_.size(); i < n; i++) {
462 total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
463 _impl_.categories_.Get(i));
464 }
465
466 cached_has_bits = _impl_._has_bits_[0];
467 if (cached_has_bits & 0x0000001fu) {
468 // optional string unit_name = 6;
469 if (cached_has_bits & 0x00000001u) {
470 total_size += 1 +
471 ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
472 this->_internal_unit_name());
473 }
474
475 // optional .perfetto.protos.CounterDescriptor.BuiltinCounterType type = 1;
476 if (cached_has_bits & 0x00000002u) {
477 total_size += 1 +
478 ::_pbi::WireFormatLite::EnumSize(this->_internal_type());
479 }
480
481 // optional .perfetto.protos.CounterDescriptor.Unit unit = 3;
482 if (cached_has_bits & 0x00000004u) {
483 total_size += 1 +
484 ::_pbi::WireFormatLite::EnumSize(this->_internal_unit());
485 }
486
487 // optional int64 unit_multiplier = 4;
488 if (cached_has_bits & 0x00000008u) {
489 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_unit_multiplier());
490 }
491
492 // optional bool is_incremental = 5;
493 if (cached_has_bits & 0x00000010u) {
494 total_size += 1 + 1;
495 }
496
497 }
498 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
499 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
500 }
501 int cached_size = ::_pbi::ToCachedSize(total_size);
502 SetCachedSize(cached_size);
503 return total_size;
504 }
505
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)506 void CounterDescriptor::CheckTypeAndMergeFrom(
507 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
508 MergeFrom(*::_pbi::DownCast<const CounterDescriptor*>(
509 &from));
510 }
511
MergeFrom(const CounterDescriptor & from)512 void CounterDescriptor::MergeFrom(const CounterDescriptor& from) {
513 CounterDescriptor* const _this = this;
514 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CounterDescriptor)
515 GOOGLE_DCHECK_NE(&from, _this);
516 ::uint32_t cached_has_bits = 0;
517 (void) cached_has_bits;
518
519 _this->_impl_.categories_.MergeFrom(from._impl_.categories_);
520 cached_has_bits = from._impl_._has_bits_[0];
521 if (cached_has_bits & 0x0000001fu) {
522 if (cached_has_bits & 0x00000001u) {
523 _this->_internal_set_unit_name(from._internal_unit_name());
524 }
525 if (cached_has_bits & 0x00000002u) {
526 _this->_impl_.type_ = from._impl_.type_;
527 }
528 if (cached_has_bits & 0x00000004u) {
529 _this->_impl_.unit_ = from._impl_.unit_;
530 }
531 if (cached_has_bits & 0x00000008u) {
532 _this->_impl_.unit_multiplier_ = from._impl_.unit_multiplier_;
533 }
534 if (cached_has_bits & 0x00000010u) {
535 _this->_impl_.is_incremental_ = from._impl_.is_incremental_;
536 }
537 _this->_impl_._has_bits_[0] |= cached_has_bits;
538 }
539 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
540 }
541
CopyFrom(const CounterDescriptor & from)542 void CounterDescriptor::CopyFrom(const CounterDescriptor& from) {
543 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CounterDescriptor)
544 if (&from == this) return;
545 Clear();
546 MergeFrom(from);
547 }
548
IsInitialized() const549 bool CounterDescriptor::IsInitialized() const {
550 return true;
551 }
552
InternalSwap(CounterDescriptor * other)553 void CounterDescriptor::InternalSwap(CounterDescriptor* other) {
554 using std::swap;
555 auto* lhs_arena = GetArenaForAllocation();
556 auto* rhs_arena = other->GetArenaForAllocation();
557 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
558 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
559 _impl_.categories_.InternalSwap(&other->_impl_.categories_);
560 ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
561 &_impl_.unit_name_, lhs_arena,
562 &other->_impl_.unit_name_, rhs_arena
563 );
564 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
565 PROTOBUF_FIELD_OFFSET(CounterDescriptor, _impl_.is_incremental_)
566 + sizeof(CounterDescriptor::_impl_.is_incremental_) // NOLINT
567 - PROTOBUF_FIELD_OFFSET(CounterDescriptor, _impl_.type_)>(
568 reinterpret_cast<char*>(&_impl_.type_),
569 reinterpret_cast<char*>(&other->_impl_.type_));
570 }
571
GetTypeName() const572 std::string CounterDescriptor::GetTypeName() const {
573 return "perfetto.protos.CounterDescriptor";
574 }
575
576
577 // @@protoc_insertion_point(namespace_scope)
578 } // namespace protos
579 } // namespace perfetto
580 PROTOBUF_NAMESPACE_OPEN
581 template<> PROTOBUF_NOINLINE ::perfetto::protos::CounterDescriptor*
CreateMaybeMessage(Arena * arena)582 Arena::CreateMaybeMessage< ::perfetto::protos::CounterDescriptor >(Arena* arena) {
583 return Arena::CreateMessageInternal< ::perfetto::protos::CounterDescriptor >(arena);
584 }
585 PROTOBUF_NAMESPACE_CLOSE
586
587 // @@protoc_insertion_point(global_scope)
588 #include <google/protobuf/port_undef.inc>
589