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