1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/system_info/cpu_info.proto
3 
4 #include "protos/perfetto/trace/system_info/cpu_info.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 {
CpuInfo_ArmCpuIdentifier(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR CpuInfo_ArmCpuIdentifier::CpuInfo_ArmCpuIdentifier(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.implementer_)*/0u
28   , /*decltype(_impl_.architecture_)*/0u
29   , /*decltype(_impl_.variant_)*/0u
30   , /*decltype(_impl_.part_)*/0u
31   , /*decltype(_impl_.revision_)*/0u} {}
32 struct CpuInfo_ArmCpuIdentifierDefaultTypeInternal {
CpuInfo_ArmCpuIdentifierDefaultTypeInternalperfetto::protos::CpuInfo_ArmCpuIdentifierDefaultTypeInternal33   PROTOBUF_CONSTEXPR CpuInfo_ArmCpuIdentifierDefaultTypeInternal()
34       : _instance(::_pbi::ConstantInitialized{}) {}
~CpuInfo_ArmCpuIdentifierDefaultTypeInternalperfetto::protos::CpuInfo_ArmCpuIdentifierDefaultTypeInternal35   ~CpuInfo_ArmCpuIdentifierDefaultTypeInternal() {}
36   union {  // NOLINT(misc-non-private-member-variables-in-classes)
37     CpuInfo_ArmCpuIdentifier _instance;
38   };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CpuInfo_ArmCpuIdentifierDefaultTypeInternal _CpuInfo_ArmCpuIdentifier_default_instance_;
CpuInfo_Cpu(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR CpuInfo_Cpu::CpuInfo_Cpu(
42     ::_pbi::ConstantInitialized): _impl_{
43     /*decltype(_impl_._has_bits_)*/{}
44   , /*decltype(_impl_._cached_size_)*/{}
45   , /*decltype(_impl_.frequencies_)*/{}
46   , /*decltype(_impl_.processor_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
47   , /*decltype(_impl_.capacity_)*/0u
48   , /*decltype(_impl_.identifier_)*/{}
49   , /*decltype(_impl_._oneof_case_)*/{}} {}
50 struct CpuInfo_CpuDefaultTypeInternal {
CpuInfo_CpuDefaultTypeInternalperfetto::protos::CpuInfo_CpuDefaultTypeInternal51   PROTOBUF_CONSTEXPR CpuInfo_CpuDefaultTypeInternal()
52       : _instance(::_pbi::ConstantInitialized{}) {}
~CpuInfo_CpuDefaultTypeInternalperfetto::protos::CpuInfo_CpuDefaultTypeInternal53   ~CpuInfo_CpuDefaultTypeInternal() {}
54   union {  // NOLINT(misc-non-private-member-variables-in-classes)
55     CpuInfo_Cpu _instance;
56   };
57 };
58 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CpuInfo_CpuDefaultTypeInternal _CpuInfo_Cpu_default_instance_;
CpuInfo(::_pbi::ConstantInitialized)59 PROTOBUF_CONSTEXPR CpuInfo::CpuInfo(
60     ::_pbi::ConstantInitialized): _impl_{
61     /*decltype(_impl_.cpus_)*/{}
62   , /*decltype(_impl_._cached_size_)*/{}} {}
63 struct CpuInfoDefaultTypeInternal {
CpuInfoDefaultTypeInternalperfetto::protos::CpuInfoDefaultTypeInternal64   PROTOBUF_CONSTEXPR CpuInfoDefaultTypeInternal()
65       : _instance(::_pbi::ConstantInitialized{}) {}
~CpuInfoDefaultTypeInternalperfetto::protos::CpuInfoDefaultTypeInternal66   ~CpuInfoDefaultTypeInternal() {}
67   union {  // NOLINT(misc-non-private-member-variables-in-classes)
68     CpuInfo _instance;
69   };
70 };
71 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CpuInfoDefaultTypeInternal _CpuInfo_default_instance_;
72 }  // namespace protos
73 }  // namespace perfetto
74 namespace perfetto {
75 namespace protos {
76 
77 // ===================================================================
78 
79 class CpuInfo_ArmCpuIdentifier::_Internal {
80  public:
81   using HasBits = decltype(std::declval<CpuInfo_ArmCpuIdentifier>()._impl_._has_bits_);
set_has_implementer(HasBits * has_bits)82   static void set_has_implementer(HasBits* has_bits) {
83     (*has_bits)[0] |= 1u;
84   }
set_has_architecture(HasBits * has_bits)85   static void set_has_architecture(HasBits* has_bits) {
86     (*has_bits)[0] |= 2u;
87   }
set_has_variant(HasBits * has_bits)88   static void set_has_variant(HasBits* has_bits) {
89     (*has_bits)[0] |= 4u;
90   }
set_has_part(HasBits * has_bits)91   static void set_has_part(HasBits* has_bits) {
92     (*has_bits)[0] |= 8u;
93   }
set_has_revision(HasBits * has_bits)94   static void set_has_revision(HasBits* has_bits) {
95     (*has_bits)[0] |= 16u;
96   }
97 };
98 
CpuInfo_ArmCpuIdentifier(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)99 CpuInfo_ArmCpuIdentifier::CpuInfo_ArmCpuIdentifier(::PROTOBUF_NAMESPACE_ID::Arena* arena,
100                          bool is_message_owned)
101   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
102   SharedCtor(arena, is_message_owned);
103   // @@protoc_insertion_point(arena_constructor:perfetto.protos.CpuInfo.ArmCpuIdentifier)
104 }
CpuInfo_ArmCpuIdentifier(const CpuInfo_ArmCpuIdentifier & from)105 CpuInfo_ArmCpuIdentifier::CpuInfo_ArmCpuIdentifier(const CpuInfo_ArmCpuIdentifier& from)
106   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
107   CpuInfo_ArmCpuIdentifier* const _this = this; (void)_this;
108   new (&_impl_) Impl_{
109       decltype(_impl_._has_bits_){from._impl_._has_bits_}
110     , /*decltype(_impl_._cached_size_)*/{}
111     , decltype(_impl_.implementer_){}
112     , decltype(_impl_.architecture_){}
113     , decltype(_impl_.variant_){}
114     , decltype(_impl_.part_){}
115     , decltype(_impl_.revision_){}};
116 
117   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
118   ::memcpy(&_impl_.implementer_, &from._impl_.implementer_,
119     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.revision_) -
120     reinterpret_cast<char*>(&_impl_.implementer_)) + sizeof(_impl_.revision_));
121   // @@protoc_insertion_point(copy_constructor:perfetto.protos.CpuInfo.ArmCpuIdentifier)
122 }
123 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)124 inline void CpuInfo_ArmCpuIdentifier::SharedCtor(
125     ::_pb::Arena* arena, bool is_message_owned) {
126   (void)arena;
127   (void)is_message_owned;
128   new (&_impl_) Impl_{
129       decltype(_impl_._has_bits_){}
130     , /*decltype(_impl_._cached_size_)*/{}
131     , decltype(_impl_.implementer_){0u}
132     , decltype(_impl_.architecture_){0u}
133     , decltype(_impl_.variant_){0u}
134     , decltype(_impl_.part_){0u}
135     , decltype(_impl_.revision_){0u}
136   };
137 }
138 
~CpuInfo_ArmCpuIdentifier()139 CpuInfo_ArmCpuIdentifier::~CpuInfo_ArmCpuIdentifier() {
140   // @@protoc_insertion_point(destructor:perfetto.protos.CpuInfo.ArmCpuIdentifier)
141   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
142   (void)arena;
143     return;
144   }
145   SharedDtor();
146 }
147 
SharedDtor()148 inline void CpuInfo_ArmCpuIdentifier::SharedDtor() {
149   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
150 }
151 
SetCachedSize(int size) const152 void CpuInfo_ArmCpuIdentifier::SetCachedSize(int size) const {
153   _impl_._cached_size_.Set(size);
154 }
155 
Clear()156 void CpuInfo_ArmCpuIdentifier::Clear() {
157 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CpuInfo.ArmCpuIdentifier)
158   ::uint32_t cached_has_bits = 0;
159   // Prevent compiler warnings about cached_has_bits being unused
160   (void) cached_has_bits;
161 
162   cached_has_bits = _impl_._has_bits_[0];
163   if (cached_has_bits & 0x0000001fu) {
164     ::memset(&_impl_.implementer_, 0, static_cast<size_t>(
165         reinterpret_cast<char*>(&_impl_.revision_) -
166         reinterpret_cast<char*>(&_impl_.implementer_)) + sizeof(_impl_.revision_));
167   }
168   _impl_._has_bits_.Clear();
169   _internal_metadata_.Clear<std::string>();
170 }
171 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)172 const char* CpuInfo_ArmCpuIdentifier::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
173 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
174   _Internal::HasBits has_bits{};
175   while (!ctx->Done(&ptr)) {
176     ::uint32_t tag;
177     ptr = ::_pbi::ReadTag(ptr, &tag);
178     switch (tag >> 3) {
179       // optional uint32 implementer = 1;
180       case 1:
181         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
182           _Internal::set_has_implementer(&has_bits);
183           _impl_.implementer_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
184           CHK_(ptr);
185         } else {
186           goto handle_unusual;
187         }
188         continue;
189       // optional uint32 architecture = 2;
190       case 2:
191         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
192           _Internal::set_has_architecture(&has_bits);
193           _impl_.architecture_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
194           CHK_(ptr);
195         } else {
196           goto handle_unusual;
197         }
198         continue;
199       // optional uint32 variant = 3;
200       case 3:
201         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
202           _Internal::set_has_variant(&has_bits);
203           _impl_.variant_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
204           CHK_(ptr);
205         } else {
206           goto handle_unusual;
207         }
208         continue;
209       // optional uint32 part = 4;
210       case 4:
211         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
212           _Internal::set_has_part(&has_bits);
213           _impl_.part_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
214           CHK_(ptr);
215         } else {
216           goto handle_unusual;
217         }
218         continue;
219       // optional uint32 revision = 5;
220       case 5:
221         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
222           _Internal::set_has_revision(&has_bits);
223           _impl_.revision_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
224           CHK_(ptr);
225         } else {
226           goto handle_unusual;
227         }
228         continue;
229       default:
230         goto handle_unusual;
231     }  // switch
232   handle_unusual:
233     if ((tag == 0) || ((tag & 7) == 4)) {
234       CHK_(ptr);
235       ctx->SetLastTag(tag);
236       goto message_done;
237     }
238     ptr = UnknownFieldParse(
239         tag,
240         _internal_metadata_.mutable_unknown_fields<std::string>(),
241         ptr, ctx);
242     CHK_(ptr != nullptr);
243   }  // while
244 message_done:
245   _impl_._has_bits_.Or(has_bits);
246   return ptr;
247 failure:
248   ptr = nullptr;
249   goto message_done;
250 #undef CHK_
251 }
252 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const253 ::uint8_t* CpuInfo_ArmCpuIdentifier::_InternalSerialize(
254     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
255   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CpuInfo.ArmCpuIdentifier)
256   ::uint32_t cached_has_bits = 0;
257   (void) cached_has_bits;
258 
259   cached_has_bits = _impl_._has_bits_[0];
260   // optional uint32 implementer = 1;
261   if (cached_has_bits & 0x00000001u) {
262     target = stream->EnsureSpace(target);
263     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_implementer(), target);
264   }
265 
266   // optional uint32 architecture = 2;
267   if (cached_has_bits & 0x00000002u) {
268     target = stream->EnsureSpace(target);
269     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_architecture(), target);
270   }
271 
272   // optional uint32 variant = 3;
273   if (cached_has_bits & 0x00000004u) {
274     target = stream->EnsureSpace(target);
275     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_variant(), target);
276   }
277 
278   // optional uint32 part = 4;
279   if (cached_has_bits & 0x00000008u) {
280     target = stream->EnsureSpace(target);
281     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_part(), target);
282   }
283 
284   // optional uint32 revision = 5;
285   if (cached_has_bits & 0x00000010u) {
286     target = stream->EnsureSpace(target);
287     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_revision(), target);
288   }
289 
290   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
291     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
292         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
293   }
294   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CpuInfo.ArmCpuIdentifier)
295   return target;
296 }
297 
ByteSizeLong() const298 size_t CpuInfo_ArmCpuIdentifier::ByteSizeLong() const {
299 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CpuInfo.ArmCpuIdentifier)
300   size_t total_size = 0;
301 
302   ::uint32_t cached_has_bits = 0;
303   // Prevent compiler warnings about cached_has_bits being unused
304   (void) cached_has_bits;
305 
306   cached_has_bits = _impl_._has_bits_[0];
307   if (cached_has_bits & 0x0000001fu) {
308     // optional uint32 implementer = 1;
309     if (cached_has_bits & 0x00000001u) {
310       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_implementer());
311     }
312 
313     // optional uint32 architecture = 2;
314     if (cached_has_bits & 0x00000002u) {
315       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_architecture());
316     }
317 
318     // optional uint32 variant = 3;
319     if (cached_has_bits & 0x00000004u) {
320       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_variant());
321     }
322 
323     // optional uint32 part = 4;
324     if (cached_has_bits & 0x00000008u) {
325       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_part());
326     }
327 
328     // optional uint32 revision = 5;
329     if (cached_has_bits & 0x00000010u) {
330       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_revision());
331     }
332 
333   }
334   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
335     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
336   }
337   int cached_size = ::_pbi::ToCachedSize(total_size);
338   SetCachedSize(cached_size);
339   return total_size;
340 }
341 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)342 void CpuInfo_ArmCpuIdentifier::CheckTypeAndMergeFrom(
343     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
344   MergeFrom(*::_pbi::DownCast<const CpuInfo_ArmCpuIdentifier*>(
345       &from));
346 }
347 
MergeFrom(const CpuInfo_ArmCpuIdentifier & from)348 void CpuInfo_ArmCpuIdentifier::MergeFrom(const CpuInfo_ArmCpuIdentifier& from) {
349   CpuInfo_ArmCpuIdentifier* const _this = this;
350   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CpuInfo.ArmCpuIdentifier)
351   GOOGLE_DCHECK_NE(&from, _this);
352   ::uint32_t cached_has_bits = 0;
353   (void) cached_has_bits;
354 
355   cached_has_bits = from._impl_._has_bits_[0];
356   if (cached_has_bits & 0x0000001fu) {
357     if (cached_has_bits & 0x00000001u) {
358       _this->_impl_.implementer_ = from._impl_.implementer_;
359     }
360     if (cached_has_bits & 0x00000002u) {
361       _this->_impl_.architecture_ = from._impl_.architecture_;
362     }
363     if (cached_has_bits & 0x00000004u) {
364       _this->_impl_.variant_ = from._impl_.variant_;
365     }
366     if (cached_has_bits & 0x00000008u) {
367       _this->_impl_.part_ = from._impl_.part_;
368     }
369     if (cached_has_bits & 0x00000010u) {
370       _this->_impl_.revision_ = from._impl_.revision_;
371     }
372     _this->_impl_._has_bits_[0] |= cached_has_bits;
373   }
374   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
375 }
376 
CopyFrom(const CpuInfo_ArmCpuIdentifier & from)377 void CpuInfo_ArmCpuIdentifier::CopyFrom(const CpuInfo_ArmCpuIdentifier& from) {
378 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CpuInfo.ArmCpuIdentifier)
379   if (&from == this) return;
380   Clear();
381   MergeFrom(from);
382 }
383 
IsInitialized() const384 bool CpuInfo_ArmCpuIdentifier::IsInitialized() const {
385   return true;
386 }
387 
InternalSwap(CpuInfo_ArmCpuIdentifier * other)388 void CpuInfo_ArmCpuIdentifier::InternalSwap(CpuInfo_ArmCpuIdentifier* other) {
389   using std::swap;
390   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
391   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
392   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
393       PROTOBUF_FIELD_OFFSET(CpuInfo_ArmCpuIdentifier, _impl_.revision_)
394       + sizeof(CpuInfo_ArmCpuIdentifier::_impl_.revision_)  // NOLINT
395       - PROTOBUF_FIELD_OFFSET(CpuInfo_ArmCpuIdentifier, _impl_.implementer_)>(
396           reinterpret_cast<char*>(&_impl_.implementer_),
397           reinterpret_cast<char*>(&other->_impl_.implementer_));
398 }
399 
GetTypeName() const400 std::string CpuInfo_ArmCpuIdentifier::GetTypeName() const {
401   return "perfetto.protos.CpuInfo.ArmCpuIdentifier";
402 }
403 
404 
405 // ===================================================================
406 
407 class CpuInfo_Cpu::_Internal {
408  public:
409   using HasBits = decltype(std::declval<CpuInfo_Cpu>()._impl_._has_bits_);
set_has_processor(HasBits * has_bits)410   static void set_has_processor(HasBits* has_bits) {
411     (*has_bits)[0] |= 1u;
412   }
set_has_capacity(HasBits * has_bits)413   static void set_has_capacity(HasBits* has_bits) {
414     (*has_bits)[0] |= 2u;
415   }
416   static const ::perfetto::protos::CpuInfo_ArmCpuIdentifier& arm_identifier(const CpuInfo_Cpu* msg);
417 };
418 
419 const ::perfetto::protos::CpuInfo_ArmCpuIdentifier&
arm_identifier(const CpuInfo_Cpu * msg)420 CpuInfo_Cpu::_Internal::arm_identifier(const CpuInfo_Cpu* msg) {
421   return *msg->_impl_.identifier_.arm_identifier_;
422 }
set_allocated_arm_identifier(::perfetto::protos::CpuInfo_ArmCpuIdentifier * arm_identifier)423 void CpuInfo_Cpu::set_allocated_arm_identifier(::perfetto::protos::CpuInfo_ArmCpuIdentifier* arm_identifier) {
424   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
425   clear_identifier();
426   if (arm_identifier) {
427     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
428       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(arm_identifier);
429     if (message_arena != submessage_arena) {
430       arm_identifier = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
431           message_arena, arm_identifier, submessage_arena);
432     }
433     set_has_arm_identifier();
434     _impl_.identifier_.arm_identifier_ = arm_identifier;
435   }
436   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.CpuInfo.Cpu.arm_identifier)
437 }
CpuInfo_Cpu(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)438 CpuInfo_Cpu::CpuInfo_Cpu(::PROTOBUF_NAMESPACE_ID::Arena* arena,
439                          bool is_message_owned)
440   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
441   SharedCtor(arena, is_message_owned);
442   // @@protoc_insertion_point(arena_constructor:perfetto.protos.CpuInfo.Cpu)
443 }
CpuInfo_Cpu(const CpuInfo_Cpu & from)444 CpuInfo_Cpu::CpuInfo_Cpu(const CpuInfo_Cpu& from)
445   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
446   CpuInfo_Cpu* const _this = this; (void)_this;
447   new (&_impl_) Impl_{
448       decltype(_impl_._has_bits_){from._impl_._has_bits_}
449     , /*decltype(_impl_._cached_size_)*/{}
450     , decltype(_impl_.frequencies_){from._impl_.frequencies_}
451     , decltype(_impl_.processor_){}
452     , decltype(_impl_.capacity_){}
453     , decltype(_impl_.identifier_){}
454     , /*decltype(_impl_._oneof_case_)*/{}};
455 
456   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
457   _impl_.processor_.InitDefault();
458   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
459     _impl_.processor_.Set("", GetArenaForAllocation());
460   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
461   if (from._internal_has_processor()) {
462     _this->_impl_.processor_.Set(from._internal_processor(),
463       _this->GetArenaForAllocation());
464   }
465   _this->_impl_.capacity_ = from._impl_.capacity_;
466   clear_has_identifier();
467   switch (from.identifier_case()) {
468     case kArmIdentifier: {
469       _this->_internal_mutable_arm_identifier()->::perfetto::protos::CpuInfo_ArmCpuIdentifier::MergeFrom(
470           from._internal_arm_identifier());
471       break;
472     }
473     case IDENTIFIER_NOT_SET: {
474       break;
475     }
476   }
477   // @@protoc_insertion_point(copy_constructor:perfetto.protos.CpuInfo.Cpu)
478 }
479 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)480 inline void CpuInfo_Cpu::SharedCtor(
481     ::_pb::Arena* arena, bool is_message_owned) {
482   (void)arena;
483   (void)is_message_owned;
484   new (&_impl_) Impl_{
485       decltype(_impl_._has_bits_){}
486     , /*decltype(_impl_._cached_size_)*/{}
487     , decltype(_impl_.frequencies_){arena}
488     , decltype(_impl_.processor_){}
489     , decltype(_impl_.capacity_){0u}
490     , decltype(_impl_.identifier_){}
491     , /*decltype(_impl_._oneof_case_)*/{}
492   };
493   _impl_.processor_.InitDefault();
494   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
495     _impl_.processor_.Set("", GetArenaForAllocation());
496   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
497   clear_has_identifier();
498 }
499 
~CpuInfo_Cpu()500 CpuInfo_Cpu::~CpuInfo_Cpu() {
501   // @@protoc_insertion_point(destructor:perfetto.protos.CpuInfo.Cpu)
502   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
503   (void)arena;
504     return;
505   }
506   SharedDtor();
507 }
508 
SharedDtor()509 inline void CpuInfo_Cpu::SharedDtor() {
510   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
511   _impl_.frequencies_.~RepeatedField();
512   _impl_.processor_.Destroy();
513   if (has_identifier()) {
514     clear_identifier();
515   }
516 }
517 
SetCachedSize(int size) const518 void CpuInfo_Cpu::SetCachedSize(int size) const {
519   _impl_._cached_size_.Set(size);
520 }
521 
clear_identifier()522 void CpuInfo_Cpu::clear_identifier() {
523 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.CpuInfo.Cpu)
524   switch (identifier_case()) {
525     case kArmIdentifier: {
526       if (GetArenaForAllocation() == nullptr) {
527         delete _impl_.identifier_.arm_identifier_;
528       }
529       break;
530     }
531     case IDENTIFIER_NOT_SET: {
532       break;
533     }
534   }
535   _impl_._oneof_case_[0] = IDENTIFIER_NOT_SET;
536 }
537 
538 
Clear()539 void CpuInfo_Cpu::Clear() {
540 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CpuInfo.Cpu)
541   ::uint32_t cached_has_bits = 0;
542   // Prevent compiler warnings about cached_has_bits being unused
543   (void) cached_has_bits;
544 
545   _impl_.frequencies_.Clear();
546   cached_has_bits = _impl_._has_bits_[0];
547   if (cached_has_bits & 0x00000001u) {
548     _impl_.processor_.ClearNonDefaultToEmpty();
549   }
550   _impl_.capacity_ = 0u;
551   clear_identifier();
552   _impl_._has_bits_.Clear();
553   _internal_metadata_.Clear<std::string>();
554 }
555 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)556 const char* CpuInfo_Cpu::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
557 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
558   _Internal::HasBits has_bits{};
559   while (!ctx->Done(&ptr)) {
560     ::uint32_t tag;
561     ptr = ::_pbi::ReadTag(ptr, &tag);
562     switch (tag >> 3) {
563       // optional string processor = 1;
564       case 1:
565         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
566           auto str = _internal_mutable_processor();
567           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
568           CHK_(ptr);
569         } else {
570           goto handle_unusual;
571         }
572         continue;
573       // repeated uint32 frequencies = 2;
574       case 2:
575         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
576           ptr -= 1;
577           do {
578             ptr += 1;
579             _internal_add_frequencies(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
580             CHK_(ptr);
581             if (!ctx->DataAvailable(ptr)) break;
582           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<16>(ptr));
583         } else if (static_cast<::uint8_t>(tag) == 18) {
584           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_frequencies(), ptr, ctx);
585           CHK_(ptr);
586         } else {
587           goto handle_unusual;
588         }
589         continue;
590       // optional uint32 capacity = 3;
591       case 3:
592         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
593           _Internal::set_has_capacity(&has_bits);
594           _impl_.capacity_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
595           CHK_(ptr);
596         } else {
597           goto handle_unusual;
598         }
599         continue;
600       // .perfetto.protos.CpuInfo.ArmCpuIdentifier arm_identifier = 4;
601       case 4:
602         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
603           ptr = ctx->ParseMessage(_internal_mutable_arm_identifier(), ptr);
604           CHK_(ptr);
605         } else {
606           goto handle_unusual;
607         }
608         continue;
609       default:
610         goto handle_unusual;
611     }  // switch
612   handle_unusual:
613     if ((tag == 0) || ((tag & 7) == 4)) {
614       CHK_(ptr);
615       ctx->SetLastTag(tag);
616       goto message_done;
617     }
618     ptr = UnknownFieldParse(
619         tag,
620         _internal_metadata_.mutable_unknown_fields<std::string>(),
621         ptr, ctx);
622     CHK_(ptr != nullptr);
623   }  // while
624 message_done:
625   _impl_._has_bits_.Or(has_bits);
626   return ptr;
627 failure:
628   ptr = nullptr;
629   goto message_done;
630 #undef CHK_
631 }
632 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const633 ::uint8_t* CpuInfo_Cpu::_InternalSerialize(
634     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
635   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CpuInfo.Cpu)
636   ::uint32_t cached_has_bits = 0;
637   (void) cached_has_bits;
638 
639   cached_has_bits = _impl_._has_bits_[0];
640   // optional string processor = 1;
641   if (cached_has_bits & 0x00000001u) {
642     target = stream->WriteStringMaybeAliased(
643         1, this->_internal_processor(), target);
644   }
645 
646   // repeated uint32 frequencies = 2;
647   for (int i = 0, n = this->_internal_frequencies_size(); i < n; i++) {
648     target = stream->EnsureSpace(target);
649     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_frequencies(i), target);
650   }
651 
652   // optional uint32 capacity = 3;
653   if (cached_has_bits & 0x00000002u) {
654     target = stream->EnsureSpace(target);
655     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_capacity(), target);
656   }
657 
658   // .perfetto.protos.CpuInfo.ArmCpuIdentifier arm_identifier = 4;
659   if (_internal_has_arm_identifier()) {
660     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
661       InternalWriteMessage(4, _Internal::arm_identifier(this),
662         _Internal::arm_identifier(this).GetCachedSize(), target, stream);
663   }
664 
665   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
666     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
667         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
668   }
669   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CpuInfo.Cpu)
670   return target;
671 }
672 
ByteSizeLong() const673 size_t CpuInfo_Cpu::ByteSizeLong() const {
674 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CpuInfo.Cpu)
675   size_t total_size = 0;
676 
677   ::uint32_t cached_has_bits = 0;
678   // Prevent compiler warnings about cached_has_bits being unused
679   (void) cached_has_bits;
680 
681   // repeated uint32 frequencies = 2;
682   {
683     size_t data_size = ::_pbi::WireFormatLite::
684       UInt32Size(this->_impl_.frequencies_);
685     total_size += 1 *
686                   ::_pbi::FromIntSize(this->_internal_frequencies_size());
687     total_size += data_size;
688   }
689 
690   cached_has_bits = _impl_._has_bits_[0];
691   if (cached_has_bits & 0x00000003u) {
692     // optional string processor = 1;
693     if (cached_has_bits & 0x00000001u) {
694       total_size += 1 +
695         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
696           this->_internal_processor());
697     }
698 
699     // optional uint32 capacity = 3;
700     if (cached_has_bits & 0x00000002u) {
701       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_capacity());
702     }
703 
704   }
705   switch (identifier_case()) {
706     // .perfetto.protos.CpuInfo.ArmCpuIdentifier arm_identifier = 4;
707     case kArmIdentifier: {
708       total_size += 1 +
709         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
710           *_impl_.identifier_.arm_identifier_);
711       break;
712     }
713     case IDENTIFIER_NOT_SET: {
714       break;
715     }
716   }
717   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
718     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
719   }
720   int cached_size = ::_pbi::ToCachedSize(total_size);
721   SetCachedSize(cached_size);
722   return total_size;
723 }
724 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)725 void CpuInfo_Cpu::CheckTypeAndMergeFrom(
726     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
727   MergeFrom(*::_pbi::DownCast<const CpuInfo_Cpu*>(
728       &from));
729 }
730 
MergeFrom(const CpuInfo_Cpu & from)731 void CpuInfo_Cpu::MergeFrom(const CpuInfo_Cpu& from) {
732   CpuInfo_Cpu* const _this = this;
733   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CpuInfo.Cpu)
734   GOOGLE_DCHECK_NE(&from, _this);
735   ::uint32_t cached_has_bits = 0;
736   (void) cached_has_bits;
737 
738   _this->_impl_.frequencies_.MergeFrom(from._impl_.frequencies_);
739   cached_has_bits = from._impl_._has_bits_[0];
740   if (cached_has_bits & 0x00000003u) {
741     if (cached_has_bits & 0x00000001u) {
742       _this->_internal_set_processor(from._internal_processor());
743     }
744     if (cached_has_bits & 0x00000002u) {
745       _this->_impl_.capacity_ = from._impl_.capacity_;
746     }
747     _this->_impl_._has_bits_[0] |= cached_has_bits;
748   }
749   switch (from.identifier_case()) {
750     case kArmIdentifier: {
751       _this->_internal_mutable_arm_identifier()->::perfetto::protos::CpuInfo_ArmCpuIdentifier::MergeFrom(
752           from._internal_arm_identifier());
753       break;
754     }
755     case IDENTIFIER_NOT_SET: {
756       break;
757     }
758   }
759   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
760 }
761 
CopyFrom(const CpuInfo_Cpu & from)762 void CpuInfo_Cpu::CopyFrom(const CpuInfo_Cpu& from) {
763 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CpuInfo.Cpu)
764   if (&from == this) return;
765   Clear();
766   MergeFrom(from);
767 }
768 
IsInitialized() const769 bool CpuInfo_Cpu::IsInitialized() const {
770   return true;
771 }
772 
InternalSwap(CpuInfo_Cpu * other)773 void CpuInfo_Cpu::InternalSwap(CpuInfo_Cpu* other) {
774   using std::swap;
775   auto* lhs_arena = GetArenaForAllocation();
776   auto* rhs_arena = other->GetArenaForAllocation();
777   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
778   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
779   _impl_.frequencies_.InternalSwap(&other->_impl_.frequencies_);
780   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
781       &_impl_.processor_, lhs_arena,
782       &other->_impl_.processor_, rhs_arena
783   );
784   swap(_impl_.capacity_, other->_impl_.capacity_);
785   swap(_impl_.identifier_, other->_impl_.identifier_);
786   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
787 }
788 
GetTypeName() const789 std::string CpuInfo_Cpu::GetTypeName() const {
790   return "perfetto.protos.CpuInfo.Cpu";
791 }
792 
793 
794 // ===================================================================
795 
796 class CpuInfo::_Internal {
797  public:
798 };
799 
CpuInfo(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)800 CpuInfo::CpuInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
801                          bool is_message_owned)
802   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
803   SharedCtor(arena, is_message_owned);
804   // @@protoc_insertion_point(arena_constructor:perfetto.protos.CpuInfo)
805 }
CpuInfo(const CpuInfo & from)806 CpuInfo::CpuInfo(const CpuInfo& from)
807   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
808   CpuInfo* const _this = this; (void)_this;
809   new (&_impl_) Impl_{
810       decltype(_impl_.cpus_){from._impl_.cpus_}
811     , /*decltype(_impl_._cached_size_)*/{}};
812 
813   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
814   // @@protoc_insertion_point(copy_constructor:perfetto.protos.CpuInfo)
815 }
816 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)817 inline void CpuInfo::SharedCtor(
818     ::_pb::Arena* arena, bool is_message_owned) {
819   (void)arena;
820   (void)is_message_owned;
821   new (&_impl_) Impl_{
822       decltype(_impl_.cpus_){arena}
823     , /*decltype(_impl_._cached_size_)*/{}
824   };
825 }
826 
~CpuInfo()827 CpuInfo::~CpuInfo() {
828   // @@protoc_insertion_point(destructor:perfetto.protos.CpuInfo)
829   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
830   (void)arena;
831     return;
832   }
833   SharedDtor();
834 }
835 
SharedDtor()836 inline void CpuInfo::SharedDtor() {
837   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
838   _impl_.cpus_.~RepeatedPtrField();
839 }
840 
SetCachedSize(int size) const841 void CpuInfo::SetCachedSize(int size) const {
842   _impl_._cached_size_.Set(size);
843 }
844 
Clear()845 void CpuInfo::Clear() {
846 // @@protoc_insertion_point(message_clear_start:perfetto.protos.CpuInfo)
847   ::uint32_t cached_has_bits = 0;
848   // Prevent compiler warnings about cached_has_bits being unused
849   (void) cached_has_bits;
850 
851   _impl_.cpus_.Clear();
852   _internal_metadata_.Clear<std::string>();
853 }
854 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)855 const char* CpuInfo::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
856 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
857   while (!ctx->Done(&ptr)) {
858     ::uint32_t tag;
859     ptr = ::_pbi::ReadTag(ptr, &tag);
860     switch (tag >> 3) {
861       // repeated .perfetto.protos.CpuInfo.Cpu cpus = 1;
862       case 1:
863         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
864           ptr -= 1;
865           do {
866             ptr += 1;
867             ptr = ctx->ParseMessage(_internal_add_cpus(), ptr);
868             CHK_(ptr);
869             if (!ctx->DataAvailable(ptr)) break;
870           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
871         } else {
872           goto handle_unusual;
873         }
874         continue;
875       default:
876         goto handle_unusual;
877     }  // switch
878   handle_unusual:
879     if ((tag == 0) || ((tag & 7) == 4)) {
880       CHK_(ptr);
881       ctx->SetLastTag(tag);
882       goto message_done;
883     }
884     ptr = UnknownFieldParse(
885         tag,
886         _internal_metadata_.mutable_unknown_fields<std::string>(),
887         ptr, ctx);
888     CHK_(ptr != nullptr);
889   }  // while
890 message_done:
891   return ptr;
892 failure:
893   ptr = nullptr;
894   goto message_done;
895 #undef CHK_
896 }
897 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const898 ::uint8_t* CpuInfo::_InternalSerialize(
899     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
900   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.CpuInfo)
901   ::uint32_t cached_has_bits = 0;
902   (void) cached_has_bits;
903 
904   // repeated .perfetto.protos.CpuInfo.Cpu cpus = 1;
905   for (unsigned i = 0,
906       n = static_cast<unsigned>(this->_internal_cpus_size()); i < n; i++) {
907     const auto& repfield = this->_internal_cpus(i);
908     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
909         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
910   }
911 
912   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
913     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
914         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
915   }
916   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.CpuInfo)
917   return target;
918 }
919 
ByteSizeLong() const920 size_t CpuInfo::ByteSizeLong() const {
921 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.CpuInfo)
922   size_t total_size = 0;
923 
924   ::uint32_t cached_has_bits = 0;
925   // Prevent compiler warnings about cached_has_bits being unused
926   (void) cached_has_bits;
927 
928   // repeated .perfetto.protos.CpuInfo.Cpu cpus = 1;
929   total_size += 1UL * this->_internal_cpus_size();
930   for (const auto& msg : this->_impl_.cpus_) {
931     total_size +=
932       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
933   }
934 
935   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
936     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
937   }
938   int cached_size = ::_pbi::ToCachedSize(total_size);
939   SetCachedSize(cached_size);
940   return total_size;
941 }
942 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)943 void CpuInfo::CheckTypeAndMergeFrom(
944     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
945   MergeFrom(*::_pbi::DownCast<const CpuInfo*>(
946       &from));
947 }
948 
MergeFrom(const CpuInfo & from)949 void CpuInfo::MergeFrom(const CpuInfo& from) {
950   CpuInfo* const _this = this;
951   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.CpuInfo)
952   GOOGLE_DCHECK_NE(&from, _this);
953   ::uint32_t cached_has_bits = 0;
954   (void) cached_has_bits;
955 
956   _this->_impl_.cpus_.MergeFrom(from._impl_.cpus_);
957   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
958 }
959 
CopyFrom(const CpuInfo & from)960 void CpuInfo::CopyFrom(const CpuInfo& from) {
961 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.CpuInfo)
962   if (&from == this) return;
963   Clear();
964   MergeFrom(from);
965 }
966 
IsInitialized() const967 bool CpuInfo::IsInitialized() const {
968   return true;
969 }
970 
InternalSwap(CpuInfo * other)971 void CpuInfo::InternalSwap(CpuInfo* other) {
972   using std::swap;
973   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
974   _impl_.cpus_.InternalSwap(&other->_impl_.cpus_);
975 }
976 
GetTypeName() const977 std::string CpuInfo::GetTypeName() const {
978   return "perfetto.protos.CpuInfo";
979 }
980 
981 
982 // @@protoc_insertion_point(namespace_scope)
983 }  // namespace protos
984 }  // namespace perfetto
985 PROTOBUF_NAMESPACE_OPEN
986 template<> PROTOBUF_NOINLINE ::perfetto::protos::CpuInfo_ArmCpuIdentifier*
CreateMaybeMessage(Arena * arena)987 Arena::CreateMaybeMessage< ::perfetto::protos::CpuInfo_ArmCpuIdentifier >(Arena* arena) {
988   return Arena::CreateMessageInternal< ::perfetto::protos::CpuInfo_ArmCpuIdentifier >(arena);
989 }
990 template<> PROTOBUF_NOINLINE ::perfetto::protos::CpuInfo_Cpu*
CreateMaybeMessage(Arena * arena)991 Arena::CreateMaybeMessage< ::perfetto::protos::CpuInfo_Cpu >(Arena* arena) {
992   return Arena::CreateMessageInternal< ::perfetto::protos::CpuInfo_Cpu >(arena);
993 }
994 template<> PROTOBUF_NOINLINE ::perfetto::protos::CpuInfo*
CreateMaybeMessage(Arena * arena)995 Arena::CreateMaybeMessage< ::perfetto::protos::CpuInfo >(Arena* arena) {
996   return Arena::CreateMessageInternal< ::perfetto::protos::CpuInfo >(arena);
997 }
998 PROTOBUF_NAMESPACE_CLOSE
999 
1000 // @@protoc_insertion_point(global_scope)
1001 #include <google/protobuf/port_undef.inc>
1002