1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/android/android_log.proto
3 
4 #include "protos/perfetto/trace/android/android_log.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 {
AndroidLogPacket_LogEvent_Arg(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR AndroidLogPacket_LogEvent_Arg::AndroidLogPacket_LogEvent_Arg(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.value_)*/{}
29   , /*decltype(_impl_._oneof_case_)*/{}} {}
30 struct AndroidLogPacket_LogEvent_ArgDefaultTypeInternal {
AndroidLogPacket_LogEvent_ArgDefaultTypeInternalperfetto::protos::AndroidLogPacket_LogEvent_ArgDefaultTypeInternal31   PROTOBUF_CONSTEXPR AndroidLogPacket_LogEvent_ArgDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidLogPacket_LogEvent_ArgDefaultTypeInternalperfetto::protos::AndroidLogPacket_LogEvent_ArgDefaultTypeInternal33   ~AndroidLogPacket_LogEvent_ArgDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     AndroidLogPacket_LogEvent_Arg _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidLogPacket_LogEvent_ArgDefaultTypeInternal _AndroidLogPacket_LogEvent_Arg_default_instance_;
AndroidLogPacket_LogEvent(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR AndroidLogPacket_LogEvent::AndroidLogPacket_LogEvent(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_._has_bits_)*/{}
42   , /*decltype(_impl_._cached_size_)*/{}
43   , /*decltype(_impl_.args_)*/{}
44   , /*decltype(_impl_.tag_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
45   , /*decltype(_impl_.message_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
46   , /*decltype(_impl_.log_id_)*/0
47   , /*decltype(_impl_.pid_)*/0
48   , /*decltype(_impl_.tid_)*/0
49   , /*decltype(_impl_.uid_)*/0
50   , /*decltype(_impl_.timestamp_)*/::uint64_t{0u}
51   , /*decltype(_impl_.prio_)*/0} {}
52 struct AndroidLogPacket_LogEventDefaultTypeInternal {
AndroidLogPacket_LogEventDefaultTypeInternalperfetto::protos::AndroidLogPacket_LogEventDefaultTypeInternal53   PROTOBUF_CONSTEXPR AndroidLogPacket_LogEventDefaultTypeInternal()
54       : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidLogPacket_LogEventDefaultTypeInternalperfetto::protos::AndroidLogPacket_LogEventDefaultTypeInternal55   ~AndroidLogPacket_LogEventDefaultTypeInternal() {}
56   union {  // NOLINT(misc-non-private-member-variables-in-classes)
57     AndroidLogPacket_LogEvent _instance;
58   };
59 };
60 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidLogPacket_LogEventDefaultTypeInternal _AndroidLogPacket_LogEvent_default_instance_;
AndroidLogPacket_Stats(::_pbi::ConstantInitialized)61 PROTOBUF_CONSTEXPR AndroidLogPacket_Stats::AndroidLogPacket_Stats(
62     ::_pbi::ConstantInitialized): _impl_{
63     /*decltype(_impl_._has_bits_)*/{}
64   , /*decltype(_impl_._cached_size_)*/{}
65   , /*decltype(_impl_.num_total_)*/::uint64_t{0u}
66   , /*decltype(_impl_.num_failed_)*/::uint64_t{0u}
67   , /*decltype(_impl_.num_skipped_)*/::uint64_t{0u}} {}
68 struct AndroidLogPacket_StatsDefaultTypeInternal {
AndroidLogPacket_StatsDefaultTypeInternalperfetto::protos::AndroidLogPacket_StatsDefaultTypeInternal69   PROTOBUF_CONSTEXPR AndroidLogPacket_StatsDefaultTypeInternal()
70       : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidLogPacket_StatsDefaultTypeInternalperfetto::protos::AndroidLogPacket_StatsDefaultTypeInternal71   ~AndroidLogPacket_StatsDefaultTypeInternal() {}
72   union {  // NOLINT(misc-non-private-member-variables-in-classes)
73     AndroidLogPacket_Stats _instance;
74   };
75 };
76 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidLogPacket_StatsDefaultTypeInternal _AndroidLogPacket_Stats_default_instance_;
AndroidLogPacket(::_pbi::ConstantInitialized)77 PROTOBUF_CONSTEXPR AndroidLogPacket::AndroidLogPacket(
78     ::_pbi::ConstantInitialized): _impl_{
79     /*decltype(_impl_._has_bits_)*/{}
80   , /*decltype(_impl_._cached_size_)*/{}
81   , /*decltype(_impl_.events_)*/{}
82   , /*decltype(_impl_.stats_)*/nullptr} {}
83 struct AndroidLogPacketDefaultTypeInternal {
AndroidLogPacketDefaultTypeInternalperfetto::protos::AndroidLogPacketDefaultTypeInternal84   PROTOBUF_CONSTEXPR AndroidLogPacketDefaultTypeInternal()
85       : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidLogPacketDefaultTypeInternalperfetto::protos::AndroidLogPacketDefaultTypeInternal86   ~AndroidLogPacketDefaultTypeInternal() {}
87   union {  // NOLINT(misc-non-private-member-variables-in-classes)
88     AndroidLogPacket _instance;
89   };
90 };
91 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidLogPacketDefaultTypeInternal _AndroidLogPacket_default_instance_;
92 }  // namespace protos
93 }  // namespace perfetto
94 namespace perfetto {
95 namespace protos {
96 
97 // ===================================================================
98 
99 class AndroidLogPacket_LogEvent_Arg::_Internal {
100  public:
101   using HasBits = decltype(std::declval<AndroidLogPacket_LogEvent_Arg>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)102   static void set_has_name(HasBits* has_bits) {
103     (*has_bits)[0] |= 1u;
104   }
105 };
106 
AndroidLogPacket_LogEvent_Arg(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)107 AndroidLogPacket_LogEvent_Arg::AndroidLogPacket_LogEvent_Arg(::PROTOBUF_NAMESPACE_ID::Arena* arena,
108                          bool is_message_owned)
109   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
110   SharedCtor(arena, is_message_owned);
111   // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
112 }
AndroidLogPacket_LogEvent_Arg(const AndroidLogPacket_LogEvent_Arg & from)113 AndroidLogPacket_LogEvent_Arg::AndroidLogPacket_LogEvent_Arg(const AndroidLogPacket_LogEvent_Arg& from)
114   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
115   AndroidLogPacket_LogEvent_Arg* const _this = this; (void)_this;
116   new (&_impl_) Impl_{
117       decltype(_impl_._has_bits_){from._impl_._has_bits_}
118     , /*decltype(_impl_._cached_size_)*/{}
119     , decltype(_impl_.name_){}
120     , decltype(_impl_.value_){}
121     , /*decltype(_impl_._oneof_case_)*/{}};
122 
123   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
124   _impl_.name_.InitDefault();
125   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
126     _impl_.name_.Set("", GetArenaForAllocation());
127   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
128   if (from._internal_has_name()) {
129     _this->_impl_.name_.Set(from._internal_name(),
130       _this->GetArenaForAllocation());
131   }
132   clear_has_value();
133   switch (from.value_case()) {
134     case kIntValue: {
135       _this->_internal_set_int_value(from._internal_int_value());
136       break;
137     }
138     case kFloatValue: {
139       _this->_internal_set_float_value(from._internal_float_value());
140       break;
141     }
142     case kStringValue: {
143       _this->_internal_set_string_value(from._internal_string_value());
144       break;
145     }
146     case VALUE_NOT_SET: {
147       break;
148     }
149   }
150   // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
151 }
152 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)153 inline void AndroidLogPacket_LogEvent_Arg::SharedCtor(
154     ::_pb::Arena* arena, bool is_message_owned) {
155   (void)arena;
156   (void)is_message_owned;
157   new (&_impl_) Impl_{
158       decltype(_impl_._has_bits_){}
159     , /*decltype(_impl_._cached_size_)*/{}
160     , decltype(_impl_.name_){}
161     , decltype(_impl_.value_){}
162     , /*decltype(_impl_._oneof_case_)*/{}
163   };
164   _impl_.name_.InitDefault();
165   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
166     _impl_.name_.Set("", GetArenaForAllocation());
167   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
168   clear_has_value();
169 }
170 
~AndroidLogPacket_LogEvent_Arg()171 AndroidLogPacket_LogEvent_Arg::~AndroidLogPacket_LogEvent_Arg() {
172   // @@protoc_insertion_point(destructor:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
173   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
174   (void)arena;
175     return;
176   }
177   SharedDtor();
178 }
179 
SharedDtor()180 inline void AndroidLogPacket_LogEvent_Arg::SharedDtor() {
181   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
182   _impl_.name_.Destroy();
183   if (has_value()) {
184     clear_value();
185   }
186 }
187 
SetCachedSize(int size) const188 void AndroidLogPacket_LogEvent_Arg::SetCachedSize(int size) const {
189   _impl_._cached_size_.Set(size);
190 }
191 
clear_value()192 void AndroidLogPacket_LogEvent_Arg::clear_value() {
193 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
194   switch (value_case()) {
195     case kIntValue: {
196       // No need to clear
197       break;
198     }
199     case kFloatValue: {
200       // No need to clear
201       break;
202     }
203     case kStringValue: {
204       _impl_.value_.string_value_.Destroy();
205       break;
206     }
207     case VALUE_NOT_SET: {
208       break;
209     }
210   }
211   _impl_._oneof_case_[0] = VALUE_NOT_SET;
212 }
213 
214 
Clear()215 void AndroidLogPacket_LogEvent_Arg::Clear() {
216 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
217   ::uint32_t cached_has_bits = 0;
218   // Prevent compiler warnings about cached_has_bits being unused
219   (void) cached_has_bits;
220 
221   cached_has_bits = _impl_._has_bits_[0];
222   if (cached_has_bits & 0x00000001u) {
223     _impl_.name_.ClearNonDefaultToEmpty();
224   }
225   clear_value();
226   _impl_._has_bits_.Clear();
227   _internal_metadata_.Clear<std::string>();
228 }
229 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)230 const char* AndroidLogPacket_LogEvent_Arg::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
231 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
232   _Internal::HasBits has_bits{};
233   while (!ctx->Done(&ptr)) {
234     ::uint32_t tag;
235     ptr = ::_pbi::ReadTag(ptr, &tag);
236     switch (tag >> 3) {
237       // optional string name = 1;
238       case 1:
239         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
240           auto str = _internal_mutable_name();
241           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
242           CHK_(ptr);
243         } else {
244           goto handle_unusual;
245         }
246         continue;
247       // int64 int_value = 2;
248       case 2:
249         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
250           _internal_set_int_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
251           CHK_(ptr);
252         } else {
253           goto handle_unusual;
254         }
255         continue;
256       // float float_value = 3;
257       case 3:
258         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 29)) {
259           _internal_set_float_value(::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr));
260           ptr += sizeof(float);
261         } else {
262           goto handle_unusual;
263         }
264         continue;
265       // string string_value = 4;
266       case 4:
267         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
268           auto str = _internal_mutable_string_value();
269           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
270           CHK_(ptr);
271         } else {
272           goto handle_unusual;
273         }
274         continue;
275       default:
276         goto handle_unusual;
277     }  // switch
278   handle_unusual:
279     if ((tag == 0) || ((tag & 7) == 4)) {
280       CHK_(ptr);
281       ctx->SetLastTag(tag);
282       goto message_done;
283     }
284     ptr = UnknownFieldParse(
285         tag,
286         _internal_metadata_.mutable_unknown_fields<std::string>(),
287         ptr, ctx);
288     CHK_(ptr != nullptr);
289   }  // while
290 message_done:
291   _impl_._has_bits_.Or(has_bits);
292   return ptr;
293 failure:
294   ptr = nullptr;
295   goto message_done;
296 #undef CHK_
297 }
298 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const299 ::uint8_t* AndroidLogPacket_LogEvent_Arg::_InternalSerialize(
300     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
301   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
302   ::uint32_t cached_has_bits = 0;
303   (void) cached_has_bits;
304 
305   cached_has_bits = _impl_._has_bits_[0];
306   // optional string name = 1;
307   if (cached_has_bits & 0x00000001u) {
308     target = stream->WriteStringMaybeAliased(
309         1, this->_internal_name(), target);
310   }
311 
312   switch (value_case()) {
313     case kIntValue: {
314       target = stream->EnsureSpace(target);
315       target = ::_pbi::WireFormatLite::WriteInt64ToArray(2, this->_internal_int_value(), target);
316       break;
317     }
318     case kFloatValue: {
319       target = stream->EnsureSpace(target);
320       target = ::_pbi::WireFormatLite::WriteFloatToArray(3, this->_internal_float_value(), target);
321       break;
322     }
323     case kStringValue: {
324       target = stream->WriteStringMaybeAliased(
325           4, this->_internal_string_value(), target);
326       break;
327     }
328     default: ;
329   }
330   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
331     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
332         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
333   }
334   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
335   return target;
336 }
337 
ByteSizeLong() const338 size_t AndroidLogPacket_LogEvent_Arg::ByteSizeLong() const {
339 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
340   size_t total_size = 0;
341 
342   ::uint32_t cached_has_bits = 0;
343   // Prevent compiler warnings about cached_has_bits being unused
344   (void) cached_has_bits;
345 
346   // optional string name = 1;
347   cached_has_bits = _impl_._has_bits_[0];
348   if (cached_has_bits & 0x00000001u) {
349     total_size += 1 +
350       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
351         this->_internal_name());
352   }
353 
354   switch (value_case()) {
355     // int64 int_value = 2;
356     case kIntValue: {
357       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_int_value());
358       break;
359     }
360     // float float_value = 3;
361     case kFloatValue: {
362       total_size += 1 + 4;
363       break;
364     }
365     // string string_value = 4;
366     case kStringValue: {
367       total_size += 1 +
368         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
369           this->_internal_string_value());
370       break;
371     }
372     case VALUE_NOT_SET: {
373       break;
374     }
375   }
376   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
377     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
378   }
379   int cached_size = ::_pbi::ToCachedSize(total_size);
380   SetCachedSize(cached_size);
381   return total_size;
382 }
383 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)384 void AndroidLogPacket_LogEvent_Arg::CheckTypeAndMergeFrom(
385     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
386   MergeFrom(*::_pbi::DownCast<const AndroidLogPacket_LogEvent_Arg*>(
387       &from));
388 }
389 
MergeFrom(const AndroidLogPacket_LogEvent_Arg & from)390 void AndroidLogPacket_LogEvent_Arg::MergeFrom(const AndroidLogPacket_LogEvent_Arg& from) {
391   AndroidLogPacket_LogEvent_Arg* const _this = this;
392   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
393   GOOGLE_DCHECK_NE(&from, _this);
394   ::uint32_t cached_has_bits = 0;
395   (void) cached_has_bits;
396 
397   if (from._internal_has_name()) {
398     _this->_internal_set_name(from._internal_name());
399   }
400   switch (from.value_case()) {
401     case kIntValue: {
402       _this->_internal_set_int_value(from._internal_int_value());
403       break;
404     }
405     case kFloatValue: {
406       _this->_internal_set_float_value(from._internal_float_value());
407       break;
408     }
409     case kStringValue: {
410       _this->_internal_set_string_value(from._internal_string_value());
411       break;
412     }
413     case VALUE_NOT_SET: {
414       break;
415     }
416   }
417   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
418 }
419 
CopyFrom(const AndroidLogPacket_LogEvent_Arg & from)420 void AndroidLogPacket_LogEvent_Arg::CopyFrom(const AndroidLogPacket_LogEvent_Arg& from) {
421 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidLogPacket.LogEvent.Arg)
422   if (&from == this) return;
423   Clear();
424   MergeFrom(from);
425 }
426 
IsInitialized() const427 bool AndroidLogPacket_LogEvent_Arg::IsInitialized() const {
428   return true;
429 }
430 
InternalSwap(AndroidLogPacket_LogEvent_Arg * other)431 void AndroidLogPacket_LogEvent_Arg::InternalSwap(AndroidLogPacket_LogEvent_Arg* other) {
432   using std::swap;
433   auto* lhs_arena = GetArenaForAllocation();
434   auto* rhs_arena = other->GetArenaForAllocation();
435   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
436   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
437   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
438       &_impl_.name_, lhs_arena,
439       &other->_impl_.name_, rhs_arena
440   );
441   swap(_impl_.value_, other->_impl_.value_);
442   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
443 }
444 
GetTypeName() const445 std::string AndroidLogPacket_LogEvent_Arg::GetTypeName() const {
446   return "perfetto.protos.AndroidLogPacket.LogEvent.Arg";
447 }
448 
449 
450 // ===================================================================
451 
452 class AndroidLogPacket_LogEvent::_Internal {
453  public:
454   using HasBits = decltype(std::declval<AndroidLogPacket_LogEvent>()._impl_._has_bits_);
set_has_log_id(HasBits * has_bits)455   static void set_has_log_id(HasBits* has_bits) {
456     (*has_bits)[0] |= 4u;
457   }
set_has_pid(HasBits * has_bits)458   static void set_has_pid(HasBits* has_bits) {
459     (*has_bits)[0] |= 8u;
460   }
set_has_tid(HasBits * has_bits)461   static void set_has_tid(HasBits* has_bits) {
462     (*has_bits)[0] |= 16u;
463   }
set_has_uid(HasBits * has_bits)464   static void set_has_uid(HasBits* has_bits) {
465     (*has_bits)[0] |= 32u;
466   }
set_has_timestamp(HasBits * has_bits)467   static void set_has_timestamp(HasBits* has_bits) {
468     (*has_bits)[0] |= 64u;
469   }
set_has_tag(HasBits * has_bits)470   static void set_has_tag(HasBits* has_bits) {
471     (*has_bits)[0] |= 1u;
472   }
set_has_prio(HasBits * has_bits)473   static void set_has_prio(HasBits* has_bits) {
474     (*has_bits)[0] |= 128u;
475   }
set_has_message(HasBits * has_bits)476   static void set_has_message(HasBits* has_bits) {
477     (*has_bits)[0] |= 2u;
478   }
479 };
480 
AndroidLogPacket_LogEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)481 AndroidLogPacket_LogEvent::AndroidLogPacket_LogEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
482                          bool is_message_owned)
483   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
484   SharedCtor(arena, is_message_owned);
485   // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidLogPacket.LogEvent)
486 }
AndroidLogPacket_LogEvent(const AndroidLogPacket_LogEvent & from)487 AndroidLogPacket_LogEvent::AndroidLogPacket_LogEvent(const AndroidLogPacket_LogEvent& from)
488   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
489   AndroidLogPacket_LogEvent* const _this = this; (void)_this;
490   new (&_impl_) Impl_{
491       decltype(_impl_._has_bits_){from._impl_._has_bits_}
492     , /*decltype(_impl_._cached_size_)*/{}
493     , decltype(_impl_.args_){from._impl_.args_}
494     , decltype(_impl_.tag_){}
495     , decltype(_impl_.message_){}
496     , decltype(_impl_.log_id_){}
497     , decltype(_impl_.pid_){}
498     , decltype(_impl_.tid_){}
499     , decltype(_impl_.uid_){}
500     , decltype(_impl_.timestamp_){}
501     , decltype(_impl_.prio_){}};
502 
503   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
504   _impl_.tag_.InitDefault();
505   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
506     _impl_.tag_.Set("", GetArenaForAllocation());
507   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
508   if (from._internal_has_tag()) {
509     _this->_impl_.tag_.Set(from._internal_tag(),
510       _this->GetArenaForAllocation());
511   }
512   _impl_.message_.InitDefault();
513   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
514     _impl_.message_.Set("", GetArenaForAllocation());
515   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
516   if (from._internal_has_message()) {
517     _this->_impl_.message_.Set(from._internal_message(),
518       _this->GetArenaForAllocation());
519   }
520   ::memcpy(&_impl_.log_id_, &from._impl_.log_id_,
521     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
522     reinterpret_cast<char*>(&_impl_.log_id_)) + sizeof(_impl_.prio_));
523   // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidLogPacket.LogEvent)
524 }
525 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)526 inline void AndroidLogPacket_LogEvent::SharedCtor(
527     ::_pb::Arena* arena, bool is_message_owned) {
528   (void)arena;
529   (void)is_message_owned;
530   new (&_impl_) Impl_{
531       decltype(_impl_._has_bits_){}
532     , /*decltype(_impl_._cached_size_)*/{}
533     , decltype(_impl_.args_){arena}
534     , decltype(_impl_.tag_){}
535     , decltype(_impl_.message_){}
536     , decltype(_impl_.log_id_){0}
537     , decltype(_impl_.pid_){0}
538     , decltype(_impl_.tid_){0}
539     , decltype(_impl_.uid_){0}
540     , decltype(_impl_.timestamp_){::uint64_t{0u}}
541     , decltype(_impl_.prio_){0}
542   };
543   _impl_.tag_.InitDefault();
544   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
545     _impl_.tag_.Set("", GetArenaForAllocation());
546   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
547   _impl_.message_.InitDefault();
548   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
549     _impl_.message_.Set("", GetArenaForAllocation());
550   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
551 }
552 
~AndroidLogPacket_LogEvent()553 AndroidLogPacket_LogEvent::~AndroidLogPacket_LogEvent() {
554   // @@protoc_insertion_point(destructor:perfetto.protos.AndroidLogPacket.LogEvent)
555   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
556   (void)arena;
557     return;
558   }
559   SharedDtor();
560 }
561 
SharedDtor()562 inline void AndroidLogPacket_LogEvent::SharedDtor() {
563   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
564   _impl_.args_.~RepeatedPtrField();
565   _impl_.tag_.Destroy();
566   _impl_.message_.Destroy();
567 }
568 
SetCachedSize(int size) const569 void AndroidLogPacket_LogEvent::SetCachedSize(int size) const {
570   _impl_._cached_size_.Set(size);
571 }
572 
Clear()573 void AndroidLogPacket_LogEvent::Clear() {
574 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidLogPacket.LogEvent)
575   ::uint32_t cached_has_bits = 0;
576   // Prevent compiler warnings about cached_has_bits being unused
577   (void) cached_has_bits;
578 
579   _impl_.args_.Clear();
580   cached_has_bits = _impl_._has_bits_[0];
581   if (cached_has_bits & 0x00000003u) {
582     if (cached_has_bits & 0x00000001u) {
583       _impl_.tag_.ClearNonDefaultToEmpty();
584     }
585     if (cached_has_bits & 0x00000002u) {
586       _impl_.message_.ClearNonDefaultToEmpty();
587     }
588   }
589   if (cached_has_bits & 0x000000fcu) {
590     ::memset(&_impl_.log_id_, 0, static_cast<size_t>(
591         reinterpret_cast<char*>(&_impl_.prio_) -
592         reinterpret_cast<char*>(&_impl_.log_id_)) + sizeof(_impl_.prio_));
593   }
594   _impl_._has_bits_.Clear();
595   _internal_metadata_.Clear<std::string>();
596 }
597 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)598 const char* AndroidLogPacket_LogEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
599 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
600   _Internal::HasBits has_bits{};
601   while (!ctx->Done(&ptr)) {
602     ::uint32_t tag;
603     ptr = ::_pbi::ReadTag(ptr, &tag);
604     switch (tag >> 3) {
605       // optional .perfetto.protos.AndroidLogId log_id = 1;
606       case 1:
607         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
608           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
609           CHK_(ptr);
610           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::AndroidLogId_IsValid(val))) {
611             _internal_set_log_id(static_cast<::perfetto::protos::AndroidLogId>(val));
612           } else {
613             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
614           }
615         } else {
616           goto handle_unusual;
617         }
618         continue;
619       // optional int32 pid = 2;
620       case 2:
621         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
622           _Internal::set_has_pid(&has_bits);
623           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
624           CHK_(ptr);
625         } else {
626           goto handle_unusual;
627         }
628         continue;
629       // optional int32 tid = 3;
630       case 3:
631         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
632           _Internal::set_has_tid(&has_bits);
633           _impl_.tid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
634           CHK_(ptr);
635         } else {
636           goto handle_unusual;
637         }
638         continue;
639       // optional int32 uid = 4;
640       case 4:
641         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
642           _Internal::set_has_uid(&has_bits);
643           _impl_.uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
644           CHK_(ptr);
645         } else {
646           goto handle_unusual;
647         }
648         continue;
649       // optional uint64 timestamp = 5;
650       case 5:
651         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
652           _Internal::set_has_timestamp(&has_bits);
653           _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
654           CHK_(ptr);
655         } else {
656           goto handle_unusual;
657         }
658         continue;
659       // optional string tag = 6;
660       case 6:
661         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
662           auto str = _internal_mutable_tag();
663           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
664           CHK_(ptr);
665         } else {
666           goto handle_unusual;
667         }
668         continue;
669       // optional .perfetto.protos.AndroidLogPriority prio = 7;
670       case 7:
671         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
672           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
673           CHK_(ptr);
674           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::AndroidLogPriority_IsValid(val))) {
675             _internal_set_prio(static_cast<::perfetto::protos::AndroidLogPriority>(val));
676           } else {
677             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(7, val, mutable_unknown_fields());
678           }
679         } else {
680           goto handle_unusual;
681         }
682         continue;
683       // optional string message = 8;
684       case 8:
685         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
686           auto str = _internal_mutable_message();
687           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
688           CHK_(ptr);
689         } else {
690           goto handle_unusual;
691         }
692         continue;
693       // repeated .perfetto.protos.AndroidLogPacket.LogEvent.Arg args = 9;
694       case 9:
695         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 74)) {
696           ptr -= 1;
697           do {
698             ptr += 1;
699             ptr = ctx->ParseMessage(_internal_add_args(), ptr);
700             CHK_(ptr);
701             if (!ctx->DataAvailable(ptr)) break;
702           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<74>(ptr));
703         } else {
704           goto handle_unusual;
705         }
706         continue;
707       default:
708         goto handle_unusual;
709     }  // switch
710   handle_unusual:
711     if ((tag == 0) || ((tag & 7) == 4)) {
712       CHK_(ptr);
713       ctx->SetLastTag(tag);
714       goto message_done;
715     }
716     ptr = UnknownFieldParse(
717         tag,
718         _internal_metadata_.mutable_unknown_fields<std::string>(),
719         ptr, ctx);
720     CHK_(ptr != nullptr);
721   }  // while
722 message_done:
723   _impl_._has_bits_.Or(has_bits);
724   return ptr;
725 failure:
726   ptr = nullptr;
727   goto message_done;
728 #undef CHK_
729 }
730 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const731 ::uint8_t* AndroidLogPacket_LogEvent::_InternalSerialize(
732     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
733   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidLogPacket.LogEvent)
734   ::uint32_t cached_has_bits = 0;
735   (void) cached_has_bits;
736 
737   cached_has_bits = _impl_._has_bits_[0];
738   // optional .perfetto.protos.AndroidLogId log_id = 1;
739   if (cached_has_bits & 0x00000004u) {
740     target = stream->EnsureSpace(target);
741     target = ::_pbi::WireFormatLite::WriteEnumToArray(
742       1, this->_internal_log_id(), target);
743   }
744 
745   // optional int32 pid = 2;
746   if (cached_has_bits & 0x00000008u) {
747     target = stream->EnsureSpace(target);
748     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_pid(), target);
749   }
750 
751   // optional int32 tid = 3;
752   if (cached_has_bits & 0x00000010u) {
753     target = stream->EnsureSpace(target);
754     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_tid(), target);
755   }
756 
757   // optional int32 uid = 4;
758   if (cached_has_bits & 0x00000020u) {
759     target = stream->EnsureSpace(target);
760     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_uid(), target);
761   }
762 
763   // optional uint64 timestamp = 5;
764   if (cached_has_bits & 0x00000040u) {
765     target = stream->EnsureSpace(target);
766     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_timestamp(), target);
767   }
768 
769   // optional string tag = 6;
770   if (cached_has_bits & 0x00000001u) {
771     target = stream->WriteStringMaybeAliased(
772         6, this->_internal_tag(), target);
773   }
774 
775   // optional .perfetto.protos.AndroidLogPriority prio = 7;
776   if (cached_has_bits & 0x00000080u) {
777     target = stream->EnsureSpace(target);
778     target = ::_pbi::WireFormatLite::WriteEnumToArray(
779       7, this->_internal_prio(), target);
780   }
781 
782   // optional string message = 8;
783   if (cached_has_bits & 0x00000002u) {
784     target = stream->WriteStringMaybeAliased(
785         8, this->_internal_message(), target);
786   }
787 
788   // repeated .perfetto.protos.AndroidLogPacket.LogEvent.Arg args = 9;
789   for (unsigned i = 0,
790       n = static_cast<unsigned>(this->_internal_args_size()); i < n; i++) {
791     const auto& repfield = this->_internal_args(i);
792     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
793         InternalWriteMessage(9, repfield, repfield.GetCachedSize(), target, stream);
794   }
795 
796   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
797     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
798         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
799   }
800   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidLogPacket.LogEvent)
801   return target;
802 }
803 
ByteSizeLong() const804 size_t AndroidLogPacket_LogEvent::ByteSizeLong() const {
805 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidLogPacket.LogEvent)
806   size_t total_size = 0;
807 
808   ::uint32_t cached_has_bits = 0;
809   // Prevent compiler warnings about cached_has_bits being unused
810   (void) cached_has_bits;
811 
812   // repeated .perfetto.protos.AndroidLogPacket.LogEvent.Arg args = 9;
813   total_size += 1UL * this->_internal_args_size();
814   for (const auto& msg : this->_impl_.args_) {
815     total_size +=
816       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
817   }
818 
819   cached_has_bits = _impl_._has_bits_[0];
820   if (cached_has_bits & 0x000000ffu) {
821     // optional string tag = 6;
822     if (cached_has_bits & 0x00000001u) {
823       total_size += 1 +
824         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
825           this->_internal_tag());
826     }
827 
828     // optional string message = 8;
829     if (cached_has_bits & 0x00000002u) {
830       total_size += 1 +
831         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
832           this->_internal_message());
833     }
834 
835     // optional .perfetto.protos.AndroidLogId log_id = 1;
836     if (cached_has_bits & 0x00000004u) {
837       total_size += 1 +
838         ::_pbi::WireFormatLite::EnumSize(this->_internal_log_id());
839     }
840 
841     // optional int32 pid = 2;
842     if (cached_has_bits & 0x00000008u) {
843       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
844     }
845 
846     // optional int32 tid = 3;
847     if (cached_has_bits & 0x00000010u) {
848       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_tid());
849     }
850 
851     // optional int32 uid = 4;
852     if (cached_has_bits & 0x00000020u) {
853       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_uid());
854     }
855 
856     // optional uint64 timestamp = 5;
857     if (cached_has_bits & 0x00000040u) {
858       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_timestamp());
859     }
860 
861     // optional .perfetto.protos.AndroidLogPriority prio = 7;
862     if (cached_has_bits & 0x00000080u) {
863       total_size += 1 +
864         ::_pbi::WireFormatLite::EnumSize(this->_internal_prio());
865     }
866 
867   }
868   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
869     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
870   }
871   int cached_size = ::_pbi::ToCachedSize(total_size);
872   SetCachedSize(cached_size);
873   return total_size;
874 }
875 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)876 void AndroidLogPacket_LogEvent::CheckTypeAndMergeFrom(
877     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
878   MergeFrom(*::_pbi::DownCast<const AndroidLogPacket_LogEvent*>(
879       &from));
880 }
881 
MergeFrom(const AndroidLogPacket_LogEvent & from)882 void AndroidLogPacket_LogEvent::MergeFrom(const AndroidLogPacket_LogEvent& from) {
883   AndroidLogPacket_LogEvent* const _this = this;
884   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidLogPacket.LogEvent)
885   GOOGLE_DCHECK_NE(&from, _this);
886   ::uint32_t cached_has_bits = 0;
887   (void) cached_has_bits;
888 
889   _this->_impl_.args_.MergeFrom(from._impl_.args_);
890   cached_has_bits = from._impl_._has_bits_[0];
891   if (cached_has_bits & 0x000000ffu) {
892     if (cached_has_bits & 0x00000001u) {
893       _this->_internal_set_tag(from._internal_tag());
894     }
895     if (cached_has_bits & 0x00000002u) {
896       _this->_internal_set_message(from._internal_message());
897     }
898     if (cached_has_bits & 0x00000004u) {
899       _this->_impl_.log_id_ = from._impl_.log_id_;
900     }
901     if (cached_has_bits & 0x00000008u) {
902       _this->_impl_.pid_ = from._impl_.pid_;
903     }
904     if (cached_has_bits & 0x00000010u) {
905       _this->_impl_.tid_ = from._impl_.tid_;
906     }
907     if (cached_has_bits & 0x00000020u) {
908       _this->_impl_.uid_ = from._impl_.uid_;
909     }
910     if (cached_has_bits & 0x00000040u) {
911       _this->_impl_.timestamp_ = from._impl_.timestamp_;
912     }
913     if (cached_has_bits & 0x00000080u) {
914       _this->_impl_.prio_ = from._impl_.prio_;
915     }
916     _this->_impl_._has_bits_[0] |= cached_has_bits;
917   }
918   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
919 }
920 
CopyFrom(const AndroidLogPacket_LogEvent & from)921 void AndroidLogPacket_LogEvent::CopyFrom(const AndroidLogPacket_LogEvent& from) {
922 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidLogPacket.LogEvent)
923   if (&from == this) return;
924   Clear();
925   MergeFrom(from);
926 }
927 
IsInitialized() const928 bool AndroidLogPacket_LogEvent::IsInitialized() const {
929   return true;
930 }
931 
InternalSwap(AndroidLogPacket_LogEvent * other)932 void AndroidLogPacket_LogEvent::InternalSwap(AndroidLogPacket_LogEvent* other) {
933   using std::swap;
934   auto* lhs_arena = GetArenaForAllocation();
935   auto* rhs_arena = other->GetArenaForAllocation();
936   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
937   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
938   _impl_.args_.InternalSwap(&other->_impl_.args_);
939   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
940       &_impl_.tag_, lhs_arena,
941       &other->_impl_.tag_, rhs_arena
942   );
943   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
944       &_impl_.message_, lhs_arena,
945       &other->_impl_.message_, rhs_arena
946   );
947   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
948       PROTOBUF_FIELD_OFFSET(AndroidLogPacket_LogEvent, _impl_.prio_)
949       + sizeof(AndroidLogPacket_LogEvent::_impl_.prio_)  // NOLINT
950       - PROTOBUF_FIELD_OFFSET(AndroidLogPacket_LogEvent, _impl_.log_id_)>(
951           reinterpret_cast<char*>(&_impl_.log_id_),
952           reinterpret_cast<char*>(&other->_impl_.log_id_));
953 }
954 
GetTypeName() const955 std::string AndroidLogPacket_LogEvent::GetTypeName() const {
956   return "perfetto.protos.AndroidLogPacket.LogEvent";
957 }
958 
959 
960 // ===================================================================
961 
962 class AndroidLogPacket_Stats::_Internal {
963  public:
964   using HasBits = decltype(std::declval<AndroidLogPacket_Stats>()._impl_._has_bits_);
set_has_num_total(HasBits * has_bits)965   static void set_has_num_total(HasBits* has_bits) {
966     (*has_bits)[0] |= 1u;
967   }
set_has_num_failed(HasBits * has_bits)968   static void set_has_num_failed(HasBits* has_bits) {
969     (*has_bits)[0] |= 2u;
970   }
set_has_num_skipped(HasBits * has_bits)971   static void set_has_num_skipped(HasBits* has_bits) {
972     (*has_bits)[0] |= 4u;
973   }
974 };
975 
AndroidLogPacket_Stats(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)976 AndroidLogPacket_Stats::AndroidLogPacket_Stats(::PROTOBUF_NAMESPACE_ID::Arena* arena,
977                          bool is_message_owned)
978   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
979   SharedCtor(arena, is_message_owned);
980   // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidLogPacket.Stats)
981 }
AndroidLogPacket_Stats(const AndroidLogPacket_Stats & from)982 AndroidLogPacket_Stats::AndroidLogPacket_Stats(const AndroidLogPacket_Stats& from)
983   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
984   AndroidLogPacket_Stats* const _this = this; (void)_this;
985   new (&_impl_) Impl_{
986       decltype(_impl_._has_bits_){from._impl_._has_bits_}
987     , /*decltype(_impl_._cached_size_)*/{}
988     , decltype(_impl_.num_total_){}
989     , decltype(_impl_.num_failed_){}
990     , decltype(_impl_.num_skipped_){}};
991 
992   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
993   ::memcpy(&_impl_.num_total_, &from._impl_.num_total_,
994     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.num_skipped_) -
995     reinterpret_cast<char*>(&_impl_.num_total_)) + sizeof(_impl_.num_skipped_));
996   // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidLogPacket.Stats)
997 }
998 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)999 inline void AndroidLogPacket_Stats::SharedCtor(
1000     ::_pb::Arena* arena, bool is_message_owned) {
1001   (void)arena;
1002   (void)is_message_owned;
1003   new (&_impl_) Impl_{
1004       decltype(_impl_._has_bits_){}
1005     , /*decltype(_impl_._cached_size_)*/{}
1006     , decltype(_impl_.num_total_){::uint64_t{0u}}
1007     , decltype(_impl_.num_failed_){::uint64_t{0u}}
1008     , decltype(_impl_.num_skipped_){::uint64_t{0u}}
1009   };
1010 }
1011 
~AndroidLogPacket_Stats()1012 AndroidLogPacket_Stats::~AndroidLogPacket_Stats() {
1013   // @@protoc_insertion_point(destructor:perfetto.protos.AndroidLogPacket.Stats)
1014   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1015   (void)arena;
1016     return;
1017   }
1018   SharedDtor();
1019 }
1020 
SharedDtor()1021 inline void AndroidLogPacket_Stats::SharedDtor() {
1022   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1023 }
1024 
SetCachedSize(int size) const1025 void AndroidLogPacket_Stats::SetCachedSize(int size) const {
1026   _impl_._cached_size_.Set(size);
1027 }
1028 
Clear()1029 void AndroidLogPacket_Stats::Clear() {
1030 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidLogPacket.Stats)
1031   ::uint32_t cached_has_bits = 0;
1032   // Prevent compiler warnings about cached_has_bits being unused
1033   (void) cached_has_bits;
1034 
1035   cached_has_bits = _impl_._has_bits_[0];
1036   if (cached_has_bits & 0x00000007u) {
1037     ::memset(&_impl_.num_total_, 0, static_cast<size_t>(
1038         reinterpret_cast<char*>(&_impl_.num_skipped_) -
1039         reinterpret_cast<char*>(&_impl_.num_total_)) + sizeof(_impl_.num_skipped_));
1040   }
1041   _impl_._has_bits_.Clear();
1042   _internal_metadata_.Clear<std::string>();
1043 }
1044 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1045 const char* AndroidLogPacket_Stats::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1046 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1047   _Internal::HasBits has_bits{};
1048   while (!ctx->Done(&ptr)) {
1049     ::uint32_t tag;
1050     ptr = ::_pbi::ReadTag(ptr, &tag);
1051     switch (tag >> 3) {
1052       // optional uint64 num_total = 1;
1053       case 1:
1054         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1055           _Internal::set_has_num_total(&has_bits);
1056           _impl_.num_total_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1057           CHK_(ptr);
1058         } else {
1059           goto handle_unusual;
1060         }
1061         continue;
1062       // optional uint64 num_failed = 2;
1063       case 2:
1064         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1065           _Internal::set_has_num_failed(&has_bits);
1066           _impl_.num_failed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1067           CHK_(ptr);
1068         } else {
1069           goto handle_unusual;
1070         }
1071         continue;
1072       // optional uint64 num_skipped = 3;
1073       case 3:
1074         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1075           _Internal::set_has_num_skipped(&has_bits);
1076           _impl_.num_skipped_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1077           CHK_(ptr);
1078         } else {
1079           goto handle_unusual;
1080         }
1081         continue;
1082       default:
1083         goto handle_unusual;
1084     }  // switch
1085   handle_unusual:
1086     if ((tag == 0) || ((tag & 7) == 4)) {
1087       CHK_(ptr);
1088       ctx->SetLastTag(tag);
1089       goto message_done;
1090     }
1091     ptr = UnknownFieldParse(
1092         tag,
1093         _internal_metadata_.mutable_unknown_fields<std::string>(),
1094         ptr, ctx);
1095     CHK_(ptr != nullptr);
1096   }  // while
1097 message_done:
1098   _impl_._has_bits_.Or(has_bits);
1099   return ptr;
1100 failure:
1101   ptr = nullptr;
1102   goto message_done;
1103 #undef CHK_
1104 }
1105 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1106 ::uint8_t* AndroidLogPacket_Stats::_InternalSerialize(
1107     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1108   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidLogPacket.Stats)
1109   ::uint32_t cached_has_bits = 0;
1110   (void) cached_has_bits;
1111 
1112   cached_has_bits = _impl_._has_bits_[0];
1113   // optional uint64 num_total = 1;
1114   if (cached_has_bits & 0x00000001u) {
1115     target = stream->EnsureSpace(target);
1116     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_num_total(), target);
1117   }
1118 
1119   // optional uint64 num_failed = 2;
1120   if (cached_has_bits & 0x00000002u) {
1121     target = stream->EnsureSpace(target);
1122     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_num_failed(), target);
1123   }
1124 
1125   // optional uint64 num_skipped = 3;
1126   if (cached_has_bits & 0x00000004u) {
1127     target = stream->EnsureSpace(target);
1128     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_num_skipped(), target);
1129   }
1130 
1131   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1132     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1133         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1134   }
1135   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidLogPacket.Stats)
1136   return target;
1137 }
1138 
ByteSizeLong() const1139 size_t AndroidLogPacket_Stats::ByteSizeLong() const {
1140 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidLogPacket.Stats)
1141   size_t total_size = 0;
1142 
1143   ::uint32_t cached_has_bits = 0;
1144   // Prevent compiler warnings about cached_has_bits being unused
1145   (void) cached_has_bits;
1146 
1147   cached_has_bits = _impl_._has_bits_[0];
1148   if (cached_has_bits & 0x00000007u) {
1149     // optional uint64 num_total = 1;
1150     if (cached_has_bits & 0x00000001u) {
1151       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_num_total());
1152     }
1153 
1154     // optional uint64 num_failed = 2;
1155     if (cached_has_bits & 0x00000002u) {
1156       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_num_failed());
1157     }
1158 
1159     // optional uint64 num_skipped = 3;
1160     if (cached_has_bits & 0x00000004u) {
1161       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_num_skipped());
1162     }
1163 
1164   }
1165   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1166     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1167   }
1168   int cached_size = ::_pbi::ToCachedSize(total_size);
1169   SetCachedSize(cached_size);
1170   return total_size;
1171 }
1172 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1173 void AndroidLogPacket_Stats::CheckTypeAndMergeFrom(
1174     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1175   MergeFrom(*::_pbi::DownCast<const AndroidLogPacket_Stats*>(
1176       &from));
1177 }
1178 
MergeFrom(const AndroidLogPacket_Stats & from)1179 void AndroidLogPacket_Stats::MergeFrom(const AndroidLogPacket_Stats& from) {
1180   AndroidLogPacket_Stats* const _this = this;
1181   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidLogPacket.Stats)
1182   GOOGLE_DCHECK_NE(&from, _this);
1183   ::uint32_t cached_has_bits = 0;
1184   (void) cached_has_bits;
1185 
1186   cached_has_bits = from._impl_._has_bits_[0];
1187   if (cached_has_bits & 0x00000007u) {
1188     if (cached_has_bits & 0x00000001u) {
1189       _this->_impl_.num_total_ = from._impl_.num_total_;
1190     }
1191     if (cached_has_bits & 0x00000002u) {
1192       _this->_impl_.num_failed_ = from._impl_.num_failed_;
1193     }
1194     if (cached_has_bits & 0x00000004u) {
1195       _this->_impl_.num_skipped_ = from._impl_.num_skipped_;
1196     }
1197     _this->_impl_._has_bits_[0] |= cached_has_bits;
1198   }
1199   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1200 }
1201 
CopyFrom(const AndroidLogPacket_Stats & from)1202 void AndroidLogPacket_Stats::CopyFrom(const AndroidLogPacket_Stats& from) {
1203 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidLogPacket.Stats)
1204   if (&from == this) return;
1205   Clear();
1206   MergeFrom(from);
1207 }
1208 
IsInitialized() const1209 bool AndroidLogPacket_Stats::IsInitialized() const {
1210   return true;
1211 }
1212 
InternalSwap(AndroidLogPacket_Stats * other)1213 void AndroidLogPacket_Stats::InternalSwap(AndroidLogPacket_Stats* other) {
1214   using std::swap;
1215   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1216   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1217   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1218       PROTOBUF_FIELD_OFFSET(AndroidLogPacket_Stats, _impl_.num_skipped_)
1219       + sizeof(AndroidLogPacket_Stats::_impl_.num_skipped_)  // NOLINT
1220       - PROTOBUF_FIELD_OFFSET(AndroidLogPacket_Stats, _impl_.num_total_)>(
1221           reinterpret_cast<char*>(&_impl_.num_total_),
1222           reinterpret_cast<char*>(&other->_impl_.num_total_));
1223 }
1224 
GetTypeName() const1225 std::string AndroidLogPacket_Stats::GetTypeName() const {
1226   return "perfetto.protos.AndroidLogPacket.Stats";
1227 }
1228 
1229 
1230 // ===================================================================
1231 
1232 class AndroidLogPacket::_Internal {
1233  public:
1234   using HasBits = decltype(std::declval<AndroidLogPacket>()._impl_._has_bits_);
1235   static const ::perfetto::protos::AndroidLogPacket_Stats& stats(const AndroidLogPacket* msg);
set_has_stats(HasBits * has_bits)1236   static void set_has_stats(HasBits* has_bits) {
1237     (*has_bits)[0] |= 1u;
1238   }
1239 };
1240 
1241 const ::perfetto::protos::AndroidLogPacket_Stats&
stats(const AndroidLogPacket * msg)1242 AndroidLogPacket::_Internal::stats(const AndroidLogPacket* msg) {
1243   return *msg->_impl_.stats_;
1244 }
AndroidLogPacket(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1245 AndroidLogPacket::AndroidLogPacket(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1246                          bool is_message_owned)
1247   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1248   SharedCtor(arena, is_message_owned);
1249   // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidLogPacket)
1250 }
AndroidLogPacket(const AndroidLogPacket & from)1251 AndroidLogPacket::AndroidLogPacket(const AndroidLogPacket& from)
1252   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1253   AndroidLogPacket* const _this = this; (void)_this;
1254   new (&_impl_) Impl_{
1255       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1256     , /*decltype(_impl_._cached_size_)*/{}
1257     , decltype(_impl_.events_){from._impl_.events_}
1258     , decltype(_impl_.stats_){nullptr}};
1259 
1260   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1261   if (from._internal_has_stats()) {
1262     _this->_impl_.stats_ = new ::perfetto::protos::AndroidLogPacket_Stats(*from._impl_.stats_);
1263   }
1264   // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidLogPacket)
1265 }
1266 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1267 inline void AndroidLogPacket::SharedCtor(
1268     ::_pb::Arena* arena, bool is_message_owned) {
1269   (void)arena;
1270   (void)is_message_owned;
1271   new (&_impl_) Impl_{
1272       decltype(_impl_._has_bits_){}
1273     , /*decltype(_impl_._cached_size_)*/{}
1274     , decltype(_impl_.events_){arena}
1275     , decltype(_impl_.stats_){nullptr}
1276   };
1277 }
1278 
~AndroidLogPacket()1279 AndroidLogPacket::~AndroidLogPacket() {
1280   // @@protoc_insertion_point(destructor:perfetto.protos.AndroidLogPacket)
1281   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1282   (void)arena;
1283     return;
1284   }
1285   SharedDtor();
1286 }
1287 
SharedDtor()1288 inline void AndroidLogPacket::SharedDtor() {
1289   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1290   _impl_.events_.~RepeatedPtrField();
1291   if (this != internal_default_instance()) delete _impl_.stats_;
1292 }
1293 
SetCachedSize(int size) const1294 void AndroidLogPacket::SetCachedSize(int size) const {
1295   _impl_._cached_size_.Set(size);
1296 }
1297 
Clear()1298 void AndroidLogPacket::Clear() {
1299 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidLogPacket)
1300   ::uint32_t cached_has_bits = 0;
1301   // Prevent compiler warnings about cached_has_bits being unused
1302   (void) cached_has_bits;
1303 
1304   _impl_.events_.Clear();
1305   cached_has_bits = _impl_._has_bits_[0];
1306   if (cached_has_bits & 0x00000001u) {
1307     GOOGLE_DCHECK(_impl_.stats_ != nullptr);
1308     _impl_.stats_->Clear();
1309   }
1310   _impl_._has_bits_.Clear();
1311   _internal_metadata_.Clear<std::string>();
1312 }
1313 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1314 const char* AndroidLogPacket::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1315 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1316   _Internal::HasBits has_bits{};
1317   while (!ctx->Done(&ptr)) {
1318     ::uint32_t tag;
1319     ptr = ::_pbi::ReadTag(ptr, &tag);
1320     switch (tag >> 3) {
1321       // repeated .perfetto.protos.AndroidLogPacket.LogEvent events = 1;
1322       case 1:
1323         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1324           ptr -= 1;
1325           do {
1326             ptr += 1;
1327             ptr = ctx->ParseMessage(_internal_add_events(), ptr);
1328             CHK_(ptr);
1329             if (!ctx->DataAvailable(ptr)) break;
1330           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1331         } else {
1332           goto handle_unusual;
1333         }
1334         continue;
1335       // optional .perfetto.protos.AndroidLogPacket.Stats stats = 2;
1336       case 2:
1337         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1338           ptr = ctx->ParseMessage(_internal_mutable_stats(), ptr);
1339           CHK_(ptr);
1340         } else {
1341           goto handle_unusual;
1342         }
1343         continue;
1344       default:
1345         goto handle_unusual;
1346     }  // switch
1347   handle_unusual:
1348     if ((tag == 0) || ((tag & 7) == 4)) {
1349       CHK_(ptr);
1350       ctx->SetLastTag(tag);
1351       goto message_done;
1352     }
1353     ptr = UnknownFieldParse(
1354         tag,
1355         _internal_metadata_.mutable_unknown_fields<std::string>(),
1356         ptr, ctx);
1357     CHK_(ptr != nullptr);
1358   }  // while
1359 message_done:
1360   _impl_._has_bits_.Or(has_bits);
1361   return ptr;
1362 failure:
1363   ptr = nullptr;
1364   goto message_done;
1365 #undef CHK_
1366 }
1367 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1368 ::uint8_t* AndroidLogPacket::_InternalSerialize(
1369     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1370   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidLogPacket)
1371   ::uint32_t cached_has_bits = 0;
1372   (void) cached_has_bits;
1373 
1374   // repeated .perfetto.protos.AndroidLogPacket.LogEvent events = 1;
1375   for (unsigned i = 0,
1376       n = static_cast<unsigned>(this->_internal_events_size()); i < n; i++) {
1377     const auto& repfield = this->_internal_events(i);
1378     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1379         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1380   }
1381 
1382   cached_has_bits = _impl_._has_bits_[0];
1383   // optional .perfetto.protos.AndroidLogPacket.Stats stats = 2;
1384   if (cached_has_bits & 0x00000001u) {
1385     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1386       InternalWriteMessage(2, _Internal::stats(this),
1387         _Internal::stats(this).GetCachedSize(), target, stream);
1388   }
1389 
1390   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1391     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1392         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1393   }
1394   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidLogPacket)
1395   return target;
1396 }
1397 
ByteSizeLong() const1398 size_t AndroidLogPacket::ByteSizeLong() const {
1399 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidLogPacket)
1400   size_t total_size = 0;
1401 
1402   ::uint32_t cached_has_bits = 0;
1403   // Prevent compiler warnings about cached_has_bits being unused
1404   (void) cached_has_bits;
1405 
1406   // repeated .perfetto.protos.AndroidLogPacket.LogEvent events = 1;
1407   total_size += 1UL * this->_internal_events_size();
1408   for (const auto& msg : this->_impl_.events_) {
1409     total_size +=
1410       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1411   }
1412 
1413   // optional .perfetto.protos.AndroidLogPacket.Stats stats = 2;
1414   cached_has_bits = _impl_._has_bits_[0];
1415   if (cached_has_bits & 0x00000001u) {
1416     total_size += 1 +
1417       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1418         *_impl_.stats_);
1419   }
1420 
1421   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1422     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1423   }
1424   int cached_size = ::_pbi::ToCachedSize(total_size);
1425   SetCachedSize(cached_size);
1426   return total_size;
1427 }
1428 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1429 void AndroidLogPacket::CheckTypeAndMergeFrom(
1430     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1431   MergeFrom(*::_pbi::DownCast<const AndroidLogPacket*>(
1432       &from));
1433 }
1434 
MergeFrom(const AndroidLogPacket & from)1435 void AndroidLogPacket::MergeFrom(const AndroidLogPacket& from) {
1436   AndroidLogPacket* const _this = this;
1437   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidLogPacket)
1438   GOOGLE_DCHECK_NE(&from, _this);
1439   ::uint32_t cached_has_bits = 0;
1440   (void) cached_has_bits;
1441 
1442   _this->_impl_.events_.MergeFrom(from._impl_.events_);
1443   if (from._internal_has_stats()) {
1444     _this->_internal_mutable_stats()->::perfetto::protos::AndroidLogPacket_Stats::MergeFrom(
1445         from._internal_stats());
1446   }
1447   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1448 }
1449 
CopyFrom(const AndroidLogPacket & from)1450 void AndroidLogPacket::CopyFrom(const AndroidLogPacket& from) {
1451 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidLogPacket)
1452   if (&from == this) return;
1453   Clear();
1454   MergeFrom(from);
1455 }
1456 
IsInitialized() const1457 bool AndroidLogPacket::IsInitialized() const {
1458   return true;
1459 }
1460 
InternalSwap(AndroidLogPacket * other)1461 void AndroidLogPacket::InternalSwap(AndroidLogPacket* other) {
1462   using std::swap;
1463   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1464   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1465   _impl_.events_.InternalSwap(&other->_impl_.events_);
1466   swap(_impl_.stats_, other->_impl_.stats_);
1467 }
1468 
GetTypeName() const1469 std::string AndroidLogPacket::GetTypeName() const {
1470   return "perfetto.protos.AndroidLogPacket";
1471 }
1472 
1473 
1474 // @@protoc_insertion_point(namespace_scope)
1475 }  // namespace protos
1476 }  // namespace perfetto
1477 PROTOBUF_NAMESPACE_OPEN
1478 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidLogPacket_LogEvent_Arg*
CreateMaybeMessage(Arena * arena)1479 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidLogPacket_LogEvent_Arg >(Arena* arena) {
1480   return Arena::CreateMessageInternal< ::perfetto::protos::AndroidLogPacket_LogEvent_Arg >(arena);
1481 }
1482 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidLogPacket_LogEvent*
CreateMaybeMessage(Arena * arena)1483 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidLogPacket_LogEvent >(Arena* arena) {
1484   return Arena::CreateMessageInternal< ::perfetto::protos::AndroidLogPacket_LogEvent >(arena);
1485 }
1486 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidLogPacket_Stats*
CreateMaybeMessage(Arena * arena)1487 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidLogPacket_Stats >(Arena* arena) {
1488   return Arena::CreateMessageInternal< ::perfetto::protos::AndroidLogPacket_Stats >(arena);
1489 }
1490 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidLogPacket*
CreateMaybeMessage(Arena * arena)1491 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidLogPacket >(Arena* arena) {
1492   return Arena::CreateMessageInternal< ::perfetto::protos::AndroidLogPacket >(arena);
1493 }
1494 PROTOBUF_NAMESPACE_CLOSE
1495 
1496 // @@protoc_insertion_point(global_scope)
1497 #include <google/protobuf/port_undef.inc>
1498