1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/common/tracing_service_state.proto
3 
4 #include "protos/perfetto/common/tracing_service_state.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 {
TracingServiceState_Producer(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR TracingServiceState_Producer::TracingServiceState_Producer(
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_.sdk_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.id_)*/0
30   , /*decltype(_impl_.uid_)*/0
31   , /*decltype(_impl_.pid_)*/0
32   , /*decltype(_impl_.frozen_)*/false} {}
33 struct TracingServiceState_ProducerDefaultTypeInternal {
TracingServiceState_ProducerDefaultTypeInternalperfetto::protos::TracingServiceState_ProducerDefaultTypeInternal34   PROTOBUF_CONSTEXPR TracingServiceState_ProducerDefaultTypeInternal()
35       : _instance(::_pbi::ConstantInitialized{}) {}
~TracingServiceState_ProducerDefaultTypeInternalperfetto::protos::TracingServiceState_ProducerDefaultTypeInternal36   ~TracingServiceState_ProducerDefaultTypeInternal() {}
37   union {  // NOLINT(misc-non-private-member-variables-in-classes)
38     TracingServiceState_Producer _instance;
39   };
40 };
41 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingServiceState_ProducerDefaultTypeInternal _TracingServiceState_Producer_default_instance_;
TracingServiceState_DataSource(::_pbi::ConstantInitialized)42 PROTOBUF_CONSTEXPR TracingServiceState_DataSource::TracingServiceState_DataSource(
43     ::_pbi::ConstantInitialized): _impl_{
44     /*decltype(_impl_._has_bits_)*/{}
45   , /*decltype(_impl_._cached_size_)*/{}
46   , /*decltype(_impl_.ds_descriptor_)*/nullptr
47   , /*decltype(_impl_.producer_id_)*/0} {}
48 struct TracingServiceState_DataSourceDefaultTypeInternal {
TracingServiceState_DataSourceDefaultTypeInternalperfetto::protos::TracingServiceState_DataSourceDefaultTypeInternal49   PROTOBUF_CONSTEXPR TracingServiceState_DataSourceDefaultTypeInternal()
50       : _instance(::_pbi::ConstantInitialized{}) {}
~TracingServiceState_DataSourceDefaultTypeInternalperfetto::protos::TracingServiceState_DataSourceDefaultTypeInternal51   ~TracingServiceState_DataSourceDefaultTypeInternal() {}
52   union {  // NOLINT(misc-non-private-member-variables-in-classes)
53     TracingServiceState_DataSource _instance;
54   };
55 };
56 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingServiceState_DataSourceDefaultTypeInternal _TracingServiceState_DataSource_default_instance_;
TracingServiceState_TracingSession(::_pbi::ConstantInitialized)57 PROTOBUF_CONSTEXPR TracingServiceState_TracingSession::TracingServiceState_TracingSession(
58     ::_pbi::ConstantInitialized): _impl_{
59     /*decltype(_impl_._has_bits_)*/{}
60   , /*decltype(_impl_._cached_size_)*/{}
61   , /*decltype(_impl_.buffer_size_kb_)*/{}
62   , /*decltype(_impl_.state_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
63   , /*decltype(_impl_.unique_session_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
64   , /*decltype(_impl_.bugreport_filename_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
65   , /*decltype(_impl_.id_)*/::uint64_t{0u}
66   , /*decltype(_impl_.consumer_uid_)*/0
67   , /*decltype(_impl_.duration_ms_)*/0u
68   , /*decltype(_impl_.start_realtime_ns_)*/::int64_t{0}
69   , /*decltype(_impl_.num_data_sources_)*/0u
70   , /*decltype(_impl_.bugreport_score_)*/0
71   , /*decltype(_impl_.is_started_)*/false} {}
72 struct TracingServiceState_TracingSessionDefaultTypeInternal {
TracingServiceState_TracingSessionDefaultTypeInternalperfetto::protos::TracingServiceState_TracingSessionDefaultTypeInternal73   PROTOBUF_CONSTEXPR TracingServiceState_TracingSessionDefaultTypeInternal()
74       : _instance(::_pbi::ConstantInitialized{}) {}
~TracingServiceState_TracingSessionDefaultTypeInternalperfetto::protos::TracingServiceState_TracingSessionDefaultTypeInternal75   ~TracingServiceState_TracingSessionDefaultTypeInternal() {}
76   union {  // NOLINT(misc-non-private-member-variables-in-classes)
77     TracingServiceState_TracingSession _instance;
78   };
79 };
80 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingServiceState_TracingSessionDefaultTypeInternal _TracingServiceState_TracingSession_default_instance_;
TracingServiceState(::_pbi::ConstantInitialized)81 PROTOBUF_CONSTEXPR TracingServiceState::TracingServiceState(
82     ::_pbi::ConstantInitialized): _impl_{
83     /*decltype(_impl_._has_bits_)*/{}
84   , /*decltype(_impl_._cached_size_)*/{}
85   , /*decltype(_impl_.producers_)*/{}
86   , /*decltype(_impl_.data_sources_)*/{}
87   , /*decltype(_impl_.tracing_sessions_)*/{}
88   , /*decltype(_impl_.tracing_service_version_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
89   , /*decltype(_impl_.num_sessions_)*/0
90   , /*decltype(_impl_.num_sessions_started_)*/0
91   , /*decltype(_impl_.supports_tracing_sessions_)*/false} {}
92 struct TracingServiceStateDefaultTypeInternal {
TracingServiceStateDefaultTypeInternalperfetto::protos::TracingServiceStateDefaultTypeInternal93   PROTOBUF_CONSTEXPR TracingServiceStateDefaultTypeInternal()
94       : _instance(::_pbi::ConstantInitialized{}) {}
~TracingServiceStateDefaultTypeInternalperfetto::protos::TracingServiceStateDefaultTypeInternal95   ~TracingServiceStateDefaultTypeInternal() {}
96   union {  // NOLINT(misc-non-private-member-variables-in-classes)
97     TracingServiceState _instance;
98   };
99 };
100 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TracingServiceStateDefaultTypeInternal _TracingServiceState_default_instance_;
101 }  // namespace protos
102 }  // namespace perfetto
103 namespace perfetto {
104 namespace protos {
105 
106 // ===================================================================
107 
108 class TracingServiceState_Producer::_Internal {
109  public:
110   using HasBits = decltype(std::declval<TracingServiceState_Producer>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)111   static void set_has_id(HasBits* has_bits) {
112     (*has_bits)[0] |= 4u;
113   }
set_has_name(HasBits * has_bits)114   static void set_has_name(HasBits* has_bits) {
115     (*has_bits)[0] |= 1u;
116   }
set_has_pid(HasBits * has_bits)117   static void set_has_pid(HasBits* has_bits) {
118     (*has_bits)[0] |= 16u;
119   }
set_has_uid(HasBits * has_bits)120   static void set_has_uid(HasBits* has_bits) {
121     (*has_bits)[0] |= 8u;
122   }
set_has_sdk_version(HasBits * has_bits)123   static void set_has_sdk_version(HasBits* has_bits) {
124     (*has_bits)[0] |= 2u;
125   }
set_has_frozen(HasBits * has_bits)126   static void set_has_frozen(HasBits* has_bits) {
127     (*has_bits)[0] |= 32u;
128   }
129 };
130 
TracingServiceState_Producer(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)131 TracingServiceState_Producer::TracingServiceState_Producer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
132                          bool is_message_owned)
133   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
134   SharedCtor(arena, is_message_owned);
135   // @@protoc_insertion_point(arena_constructor:perfetto.protos.TracingServiceState.Producer)
136 }
TracingServiceState_Producer(const TracingServiceState_Producer & from)137 TracingServiceState_Producer::TracingServiceState_Producer(const TracingServiceState_Producer& from)
138   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
139   TracingServiceState_Producer* const _this = this; (void)_this;
140   new (&_impl_) Impl_{
141       decltype(_impl_._has_bits_){from._impl_._has_bits_}
142     , /*decltype(_impl_._cached_size_)*/{}
143     , decltype(_impl_.name_){}
144     , decltype(_impl_.sdk_version_){}
145     , decltype(_impl_.id_){}
146     , decltype(_impl_.uid_){}
147     , decltype(_impl_.pid_){}
148     , decltype(_impl_.frozen_){}};
149 
150   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
151   _impl_.name_.InitDefault();
152   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
153     _impl_.name_.Set("", GetArenaForAllocation());
154   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
155   if (from._internal_has_name()) {
156     _this->_impl_.name_.Set(from._internal_name(),
157       _this->GetArenaForAllocation());
158   }
159   _impl_.sdk_version_.InitDefault();
160   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
161     _impl_.sdk_version_.Set("", GetArenaForAllocation());
162   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
163   if (from._internal_has_sdk_version()) {
164     _this->_impl_.sdk_version_.Set(from._internal_sdk_version(),
165       _this->GetArenaForAllocation());
166   }
167   ::memcpy(&_impl_.id_, &from._impl_.id_,
168     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.frozen_) -
169     reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.frozen_));
170   // @@protoc_insertion_point(copy_constructor:perfetto.protos.TracingServiceState.Producer)
171 }
172 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)173 inline void TracingServiceState_Producer::SharedCtor(
174     ::_pb::Arena* arena, bool is_message_owned) {
175   (void)arena;
176   (void)is_message_owned;
177   new (&_impl_) Impl_{
178       decltype(_impl_._has_bits_){}
179     , /*decltype(_impl_._cached_size_)*/{}
180     , decltype(_impl_.name_){}
181     , decltype(_impl_.sdk_version_){}
182     , decltype(_impl_.id_){0}
183     , decltype(_impl_.uid_){0}
184     , decltype(_impl_.pid_){0}
185     , decltype(_impl_.frozen_){false}
186   };
187   _impl_.name_.InitDefault();
188   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
189     _impl_.name_.Set("", GetArenaForAllocation());
190   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
191   _impl_.sdk_version_.InitDefault();
192   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
193     _impl_.sdk_version_.Set("", GetArenaForAllocation());
194   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
195 }
196 
~TracingServiceState_Producer()197 TracingServiceState_Producer::~TracingServiceState_Producer() {
198   // @@protoc_insertion_point(destructor:perfetto.protos.TracingServiceState.Producer)
199   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
200   (void)arena;
201     return;
202   }
203   SharedDtor();
204 }
205 
SharedDtor()206 inline void TracingServiceState_Producer::SharedDtor() {
207   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
208   _impl_.name_.Destroy();
209   _impl_.sdk_version_.Destroy();
210 }
211 
SetCachedSize(int size) const212 void TracingServiceState_Producer::SetCachedSize(int size) const {
213   _impl_._cached_size_.Set(size);
214 }
215 
Clear()216 void TracingServiceState_Producer::Clear() {
217 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TracingServiceState.Producer)
218   ::uint32_t cached_has_bits = 0;
219   // Prevent compiler warnings about cached_has_bits being unused
220   (void) cached_has_bits;
221 
222   cached_has_bits = _impl_._has_bits_[0];
223   if (cached_has_bits & 0x00000003u) {
224     if (cached_has_bits & 0x00000001u) {
225       _impl_.name_.ClearNonDefaultToEmpty();
226     }
227     if (cached_has_bits & 0x00000002u) {
228       _impl_.sdk_version_.ClearNonDefaultToEmpty();
229     }
230   }
231   if (cached_has_bits & 0x0000003cu) {
232     ::memset(&_impl_.id_, 0, static_cast<size_t>(
233         reinterpret_cast<char*>(&_impl_.frozen_) -
234         reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.frozen_));
235   }
236   _impl_._has_bits_.Clear();
237   _internal_metadata_.Clear<std::string>();
238 }
239 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)240 const char* TracingServiceState_Producer::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
241 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
242   _Internal::HasBits has_bits{};
243   while (!ctx->Done(&ptr)) {
244     ::uint32_t tag;
245     ptr = ::_pbi::ReadTag(ptr, &tag);
246     switch (tag >> 3) {
247       // optional int32 id = 1;
248       case 1:
249         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
250           _Internal::set_has_id(&has_bits);
251           _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
252           CHK_(ptr);
253         } else {
254           goto handle_unusual;
255         }
256         continue;
257       // optional string name = 2;
258       case 2:
259         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
260           auto str = _internal_mutable_name();
261           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
262           CHK_(ptr);
263         } else {
264           goto handle_unusual;
265         }
266         continue;
267       // optional int32 uid = 3;
268       case 3:
269         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
270           _Internal::set_has_uid(&has_bits);
271           _impl_.uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
272           CHK_(ptr);
273         } else {
274           goto handle_unusual;
275         }
276         continue;
277       // optional string sdk_version = 4;
278       case 4:
279         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
280           auto str = _internal_mutable_sdk_version();
281           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
282           CHK_(ptr);
283         } else {
284           goto handle_unusual;
285         }
286         continue;
287       // optional int32 pid = 5;
288       case 5:
289         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
290           _Internal::set_has_pid(&has_bits);
291           _impl_.pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
292           CHK_(ptr);
293         } else {
294           goto handle_unusual;
295         }
296         continue;
297       // optional bool frozen = 6;
298       case 6:
299         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
300           _Internal::set_has_frozen(&has_bits);
301           _impl_.frozen_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
302           CHK_(ptr);
303         } else {
304           goto handle_unusual;
305         }
306         continue;
307       default:
308         goto handle_unusual;
309     }  // switch
310   handle_unusual:
311     if ((tag == 0) || ((tag & 7) == 4)) {
312       CHK_(ptr);
313       ctx->SetLastTag(tag);
314       goto message_done;
315     }
316     ptr = UnknownFieldParse(
317         tag,
318         _internal_metadata_.mutable_unknown_fields<std::string>(),
319         ptr, ctx);
320     CHK_(ptr != nullptr);
321   }  // while
322 message_done:
323   _impl_._has_bits_.Or(has_bits);
324   return ptr;
325 failure:
326   ptr = nullptr;
327   goto message_done;
328 #undef CHK_
329 }
330 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const331 ::uint8_t* TracingServiceState_Producer::_InternalSerialize(
332     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
333   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TracingServiceState.Producer)
334   ::uint32_t cached_has_bits = 0;
335   (void) cached_has_bits;
336 
337   cached_has_bits = _impl_._has_bits_[0];
338   // optional int32 id = 1;
339   if (cached_has_bits & 0x00000004u) {
340     target = stream->EnsureSpace(target);
341     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_id(), target);
342   }
343 
344   // optional string name = 2;
345   if (cached_has_bits & 0x00000001u) {
346     target = stream->WriteStringMaybeAliased(
347         2, this->_internal_name(), target);
348   }
349 
350   // optional int32 uid = 3;
351   if (cached_has_bits & 0x00000008u) {
352     target = stream->EnsureSpace(target);
353     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_uid(), target);
354   }
355 
356   // optional string sdk_version = 4;
357   if (cached_has_bits & 0x00000002u) {
358     target = stream->WriteStringMaybeAliased(
359         4, this->_internal_sdk_version(), target);
360   }
361 
362   // optional int32 pid = 5;
363   if (cached_has_bits & 0x00000010u) {
364     target = stream->EnsureSpace(target);
365     target = ::_pbi::WireFormatLite::WriteInt32ToArray(5, this->_internal_pid(), target);
366   }
367 
368   // optional bool frozen = 6;
369   if (cached_has_bits & 0x00000020u) {
370     target = stream->EnsureSpace(target);
371     target = ::_pbi::WireFormatLite::WriteBoolToArray(6, this->_internal_frozen(), target);
372   }
373 
374   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
375     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
376         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
377   }
378   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TracingServiceState.Producer)
379   return target;
380 }
381 
ByteSizeLong() const382 size_t TracingServiceState_Producer::ByteSizeLong() const {
383 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TracingServiceState.Producer)
384   size_t total_size = 0;
385 
386   ::uint32_t cached_has_bits = 0;
387   // Prevent compiler warnings about cached_has_bits being unused
388   (void) cached_has_bits;
389 
390   cached_has_bits = _impl_._has_bits_[0];
391   if (cached_has_bits & 0x0000003fu) {
392     // optional string name = 2;
393     if (cached_has_bits & 0x00000001u) {
394       total_size += 1 +
395         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
396           this->_internal_name());
397     }
398 
399     // optional string sdk_version = 4;
400     if (cached_has_bits & 0x00000002u) {
401       total_size += 1 +
402         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
403           this->_internal_sdk_version());
404     }
405 
406     // optional int32 id = 1;
407     if (cached_has_bits & 0x00000004u) {
408       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_id());
409     }
410 
411     // optional int32 uid = 3;
412     if (cached_has_bits & 0x00000008u) {
413       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_uid());
414     }
415 
416     // optional int32 pid = 5;
417     if (cached_has_bits & 0x00000010u) {
418       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_pid());
419     }
420 
421     // optional bool frozen = 6;
422     if (cached_has_bits & 0x00000020u) {
423       total_size += 1 + 1;
424     }
425 
426   }
427   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
428     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
429   }
430   int cached_size = ::_pbi::ToCachedSize(total_size);
431   SetCachedSize(cached_size);
432   return total_size;
433 }
434 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)435 void TracingServiceState_Producer::CheckTypeAndMergeFrom(
436     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
437   MergeFrom(*::_pbi::DownCast<const TracingServiceState_Producer*>(
438       &from));
439 }
440 
MergeFrom(const TracingServiceState_Producer & from)441 void TracingServiceState_Producer::MergeFrom(const TracingServiceState_Producer& from) {
442   TracingServiceState_Producer* const _this = this;
443   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TracingServiceState.Producer)
444   GOOGLE_DCHECK_NE(&from, _this);
445   ::uint32_t cached_has_bits = 0;
446   (void) cached_has_bits;
447 
448   cached_has_bits = from._impl_._has_bits_[0];
449   if (cached_has_bits & 0x0000003fu) {
450     if (cached_has_bits & 0x00000001u) {
451       _this->_internal_set_name(from._internal_name());
452     }
453     if (cached_has_bits & 0x00000002u) {
454       _this->_internal_set_sdk_version(from._internal_sdk_version());
455     }
456     if (cached_has_bits & 0x00000004u) {
457       _this->_impl_.id_ = from._impl_.id_;
458     }
459     if (cached_has_bits & 0x00000008u) {
460       _this->_impl_.uid_ = from._impl_.uid_;
461     }
462     if (cached_has_bits & 0x00000010u) {
463       _this->_impl_.pid_ = from._impl_.pid_;
464     }
465     if (cached_has_bits & 0x00000020u) {
466       _this->_impl_.frozen_ = from._impl_.frozen_;
467     }
468     _this->_impl_._has_bits_[0] |= cached_has_bits;
469   }
470   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
471 }
472 
CopyFrom(const TracingServiceState_Producer & from)473 void TracingServiceState_Producer::CopyFrom(const TracingServiceState_Producer& from) {
474 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TracingServiceState.Producer)
475   if (&from == this) return;
476   Clear();
477   MergeFrom(from);
478 }
479 
IsInitialized() const480 bool TracingServiceState_Producer::IsInitialized() const {
481   return true;
482 }
483 
InternalSwap(TracingServiceState_Producer * other)484 void TracingServiceState_Producer::InternalSwap(TracingServiceState_Producer* other) {
485   using std::swap;
486   auto* lhs_arena = GetArenaForAllocation();
487   auto* rhs_arena = other->GetArenaForAllocation();
488   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
489   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
490   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
491       &_impl_.name_, lhs_arena,
492       &other->_impl_.name_, rhs_arena
493   );
494   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
495       &_impl_.sdk_version_, lhs_arena,
496       &other->_impl_.sdk_version_, rhs_arena
497   );
498   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
499       PROTOBUF_FIELD_OFFSET(TracingServiceState_Producer, _impl_.frozen_)
500       + sizeof(TracingServiceState_Producer::_impl_.frozen_)  // NOLINT
501       - PROTOBUF_FIELD_OFFSET(TracingServiceState_Producer, _impl_.id_)>(
502           reinterpret_cast<char*>(&_impl_.id_),
503           reinterpret_cast<char*>(&other->_impl_.id_));
504 }
505 
GetTypeName() const506 std::string TracingServiceState_Producer::GetTypeName() const {
507   return "perfetto.protos.TracingServiceState.Producer";
508 }
509 
510 
511 // ===================================================================
512 
513 class TracingServiceState_DataSource::_Internal {
514  public:
515   using HasBits = decltype(std::declval<TracingServiceState_DataSource>()._impl_._has_bits_);
516   static const ::perfetto::protos::DataSourceDescriptor& ds_descriptor(const TracingServiceState_DataSource* msg);
set_has_ds_descriptor(HasBits * has_bits)517   static void set_has_ds_descriptor(HasBits* has_bits) {
518     (*has_bits)[0] |= 1u;
519   }
set_has_producer_id(HasBits * has_bits)520   static void set_has_producer_id(HasBits* has_bits) {
521     (*has_bits)[0] |= 2u;
522   }
523 };
524 
525 const ::perfetto::protos::DataSourceDescriptor&
ds_descriptor(const TracingServiceState_DataSource * msg)526 TracingServiceState_DataSource::_Internal::ds_descriptor(const TracingServiceState_DataSource* msg) {
527   return *msg->_impl_.ds_descriptor_;
528 }
clear_ds_descriptor()529 void TracingServiceState_DataSource::clear_ds_descriptor() {
530   if (_impl_.ds_descriptor_ != nullptr) _impl_.ds_descriptor_->Clear();
531   _impl_._has_bits_[0] &= ~0x00000001u;
532 }
TracingServiceState_DataSource(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)533 TracingServiceState_DataSource::TracingServiceState_DataSource(::PROTOBUF_NAMESPACE_ID::Arena* arena,
534                          bool is_message_owned)
535   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
536   SharedCtor(arena, is_message_owned);
537   // @@protoc_insertion_point(arena_constructor:perfetto.protos.TracingServiceState.DataSource)
538 }
TracingServiceState_DataSource(const TracingServiceState_DataSource & from)539 TracingServiceState_DataSource::TracingServiceState_DataSource(const TracingServiceState_DataSource& from)
540   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
541   TracingServiceState_DataSource* const _this = this; (void)_this;
542   new (&_impl_) Impl_{
543       decltype(_impl_._has_bits_){from._impl_._has_bits_}
544     , /*decltype(_impl_._cached_size_)*/{}
545     , decltype(_impl_.ds_descriptor_){nullptr}
546     , decltype(_impl_.producer_id_){}};
547 
548   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
549   if (from._internal_has_ds_descriptor()) {
550     _this->_impl_.ds_descriptor_ = new ::perfetto::protos::DataSourceDescriptor(*from._impl_.ds_descriptor_);
551   }
552   _this->_impl_.producer_id_ = from._impl_.producer_id_;
553   // @@protoc_insertion_point(copy_constructor:perfetto.protos.TracingServiceState.DataSource)
554 }
555 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)556 inline void TracingServiceState_DataSource::SharedCtor(
557     ::_pb::Arena* arena, bool is_message_owned) {
558   (void)arena;
559   (void)is_message_owned;
560   new (&_impl_) Impl_{
561       decltype(_impl_._has_bits_){}
562     , /*decltype(_impl_._cached_size_)*/{}
563     , decltype(_impl_.ds_descriptor_){nullptr}
564     , decltype(_impl_.producer_id_){0}
565   };
566 }
567 
~TracingServiceState_DataSource()568 TracingServiceState_DataSource::~TracingServiceState_DataSource() {
569   // @@protoc_insertion_point(destructor:perfetto.protos.TracingServiceState.DataSource)
570   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
571   (void)arena;
572     return;
573   }
574   SharedDtor();
575 }
576 
SharedDtor()577 inline void TracingServiceState_DataSource::SharedDtor() {
578   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
579   if (this != internal_default_instance()) delete _impl_.ds_descriptor_;
580 }
581 
SetCachedSize(int size) const582 void TracingServiceState_DataSource::SetCachedSize(int size) const {
583   _impl_._cached_size_.Set(size);
584 }
585 
Clear()586 void TracingServiceState_DataSource::Clear() {
587 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TracingServiceState.DataSource)
588   ::uint32_t cached_has_bits = 0;
589   // Prevent compiler warnings about cached_has_bits being unused
590   (void) cached_has_bits;
591 
592   cached_has_bits = _impl_._has_bits_[0];
593   if (cached_has_bits & 0x00000001u) {
594     GOOGLE_DCHECK(_impl_.ds_descriptor_ != nullptr);
595     _impl_.ds_descriptor_->Clear();
596   }
597   _impl_.producer_id_ = 0;
598   _impl_._has_bits_.Clear();
599   _internal_metadata_.Clear<std::string>();
600 }
601 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)602 const char* TracingServiceState_DataSource::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
603 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
604   _Internal::HasBits has_bits{};
605   while (!ctx->Done(&ptr)) {
606     ::uint32_t tag;
607     ptr = ::_pbi::ReadTag(ptr, &tag);
608     switch (tag >> 3) {
609       // optional .perfetto.protos.DataSourceDescriptor ds_descriptor = 1;
610       case 1:
611         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
612           ptr = ctx->ParseMessage(_internal_mutable_ds_descriptor(), ptr);
613           CHK_(ptr);
614         } else {
615           goto handle_unusual;
616         }
617         continue;
618       // optional int32 producer_id = 2;
619       case 2:
620         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
621           _Internal::set_has_producer_id(&has_bits);
622           _impl_.producer_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
623           CHK_(ptr);
624         } else {
625           goto handle_unusual;
626         }
627         continue;
628       default:
629         goto handle_unusual;
630     }  // switch
631   handle_unusual:
632     if ((tag == 0) || ((tag & 7) == 4)) {
633       CHK_(ptr);
634       ctx->SetLastTag(tag);
635       goto message_done;
636     }
637     ptr = UnknownFieldParse(
638         tag,
639         _internal_metadata_.mutable_unknown_fields<std::string>(),
640         ptr, ctx);
641     CHK_(ptr != nullptr);
642   }  // while
643 message_done:
644   _impl_._has_bits_.Or(has_bits);
645   return ptr;
646 failure:
647   ptr = nullptr;
648   goto message_done;
649 #undef CHK_
650 }
651 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const652 ::uint8_t* TracingServiceState_DataSource::_InternalSerialize(
653     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
654   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TracingServiceState.DataSource)
655   ::uint32_t cached_has_bits = 0;
656   (void) cached_has_bits;
657 
658   cached_has_bits = _impl_._has_bits_[0];
659   // optional .perfetto.protos.DataSourceDescriptor ds_descriptor = 1;
660   if (cached_has_bits & 0x00000001u) {
661     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
662       InternalWriteMessage(1, _Internal::ds_descriptor(this),
663         _Internal::ds_descriptor(this).GetCachedSize(), target, stream);
664   }
665 
666   // optional int32 producer_id = 2;
667   if (cached_has_bits & 0x00000002u) {
668     target = stream->EnsureSpace(target);
669     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_producer_id(), target);
670   }
671 
672   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
673     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
674         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
675   }
676   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TracingServiceState.DataSource)
677   return target;
678 }
679 
ByteSizeLong() const680 size_t TracingServiceState_DataSource::ByteSizeLong() const {
681 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TracingServiceState.DataSource)
682   size_t total_size = 0;
683 
684   ::uint32_t cached_has_bits = 0;
685   // Prevent compiler warnings about cached_has_bits being unused
686   (void) cached_has_bits;
687 
688   cached_has_bits = _impl_._has_bits_[0];
689   if (cached_has_bits & 0x00000003u) {
690     // optional .perfetto.protos.DataSourceDescriptor ds_descriptor = 1;
691     if (cached_has_bits & 0x00000001u) {
692       total_size += 1 +
693         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
694           *_impl_.ds_descriptor_);
695     }
696 
697     // optional int32 producer_id = 2;
698     if (cached_has_bits & 0x00000002u) {
699       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_producer_id());
700     }
701 
702   }
703   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
704     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
705   }
706   int cached_size = ::_pbi::ToCachedSize(total_size);
707   SetCachedSize(cached_size);
708   return total_size;
709 }
710 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)711 void TracingServiceState_DataSource::CheckTypeAndMergeFrom(
712     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
713   MergeFrom(*::_pbi::DownCast<const TracingServiceState_DataSource*>(
714       &from));
715 }
716 
MergeFrom(const TracingServiceState_DataSource & from)717 void TracingServiceState_DataSource::MergeFrom(const TracingServiceState_DataSource& from) {
718   TracingServiceState_DataSource* const _this = this;
719   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TracingServiceState.DataSource)
720   GOOGLE_DCHECK_NE(&from, _this);
721   ::uint32_t cached_has_bits = 0;
722   (void) cached_has_bits;
723 
724   cached_has_bits = from._impl_._has_bits_[0];
725   if (cached_has_bits & 0x00000003u) {
726     if (cached_has_bits & 0x00000001u) {
727       _this->_internal_mutable_ds_descriptor()->::perfetto::protos::DataSourceDescriptor::MergeFrom(
728           from._internal_ds_descriptor());
729     }
730     if (cached_has_bits & 0x00000002u) {
731       _this->_impl_.producer_id_ = from._impl_.producer_id_;
732     }
733     _this->_impl_._has_bits_[0] |= cached_has_bits;
734   }
735   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
736 }
737 
CopyFrom(const TracingServiceState_DataSource & from)738 void TracingServiceState_DataSource::CopyFrom(const TracingServiceState_DataSource& from) {
739 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TracingServiceState.DataSource)
740   if (&from == this) return;
741   Clear();
742   MergeFrom(from);
743 }
744 
IsInitialized() const745 bool TracingServiceState_DataSource::IsInitialized() const {
746   return true;
747 }
748 
InternalSwap(TracingServiceState_DataSource * other)749 void TracingServiceState_DataSource::InternalSwap(TracingServiceState_DataSource* other) {
750   using std::swap;
751   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
752   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
753   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
754       PROTOBUF_FIELD_OFFSET(TracingServiceState_DataSource, _impl_.producer_id_)
755       + sizeof(TracingServiceState_DataSource::_impl_.producer_id_)  // NOLINT
756       - PROTOBUF_FIELD_OFFSET(TracingServiceState_DataSource, _impl_.ds_descriptor_)>(
757           reinterpret_cast<char*>(&_impl_.ds_descriptor_),
758           reinterpret_cast<char*>(&other->_impl_.ds_descriptor_));
759 }
760 
GetTypeName() const761 std::string TracingServiceState_DataSource::GetTypeName() const {
762   return "perfetto.protos.TracingServiceState.DataSource";
763 }
764 
765 
766 // ===================================================================
767 
768 class TracingServiceState_TracingSession::_Internal {
769  public:
770   using HasBits = decltype(std::declval<TracingServiceState_TracingSession>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)771   static void set_has_id(HasBits* has_bits) {
772     (*has_bits)[0] |= 8u;
773   }
set_has_consumer_uid(HasBits * has_bits)774   static void set_has_consumer_uid(HasBits* has_bits) {
775     (*has_bits)[0] |= 16u;
776   }
set_has_state(HasBits * has_bits)777   static void set_has_state(HasBits* has_bits) {
778     (*has_bits)[0] |= 1u;
779   }
set_has_unique_session_name(HasBits * has_bits)780   static void set_has_unique_session_name(HasBits* has_bits) {
781     (*has_bits)[0] |= 2u;
782   }
set_has_duration_ms(HasBits * has_bits)783   static void set_has_duration_ms(HasBits* has_bits) {
784     (*has_bits)[0] |= 32u;
785   }
set_has_num_data_sources(HasBits * has_bits)786   static void set_has_num_data_sources(HasBits* has_bits) {
787     (*has_bits)[0] |= 128u;
788   }
set_has_start_realtime_ns(HasBits * has_bits)789   static void set_has_start_realtime_ns(HasBits* has_bits) {
790     (*has_bits)[0] |= 64u;
791   }
set_has_bugreport_score(HasBits * has_bits)792   static void set_has_bugreport_score(HasBits* has_bits) {
793     (*has_bits)[0] |= 256u;
794   }
set_has_bugreport_filename(HasBits * has_bits)795   static void set_has_bugreport_filename(HasBits* has_bits) {
796     (*has_bits)[0] |= 4u;
797   }
set_has_is_started(HasBits * has_bits)798   static void set_has_is_started(HasBits* has_bits) {
799     (*has_bits)[0] |= 512u;
800   }
801 };
802 
TracingServiceState_TracingSession(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)803 TracingServiceState_TracingSession::TracingServiceState_TracingSession(::PROTOBUF_NAMESPACE_ID::Arena* arena,
804                          bool is_message_owned)
805   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
806   SharedCtor(arena, is_message_owned);
807   // @@protoc_insertion_point(arena_constructor:perfetto.protos.TracingServiceState.TracingSession)
808 }
TracingServiceState_TracingSession(const TracingServiceState_TracingSession & from)809 TracingServiceState_TracingSession::TracingServiceState_TracingSession(const TracingServiceState_TracingSession& from)
810   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
811   TracingServiceState_TracingSession* const _this = this; (void)_this;
812   new (&_impl_) Impl_{
813       decltype(_impl_._has_bits_){from._impl_._has_bits_}
814     , /*decltype(_impl_._cached_size_)*/{}
815     , decltype(_impl_.buffer_size_kb_){from._impl_.buffer_size_kb_}
816     , decltype(_impl_.state_){}
817     , decltype(_impl_.unique_session_name_){}
818     , decltype(_impl_.bugreport_filename_){}
819     , decltype(_impl_.id_){}
820     , decltype(_impl_.consumer_uid_){}
821     , decltype(_impl_.duration_ms_){}
822     , decltype(_impl_.start_realtime_ns_){}
823     , decltype(_impl_.num_data_sources_){}
824     , decltype(_impl_.bugreport_score_){}
825     , decltype(_impl_.is_started_){}};
826 
827   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
828   _impl_.state_.InitDefault();
829   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
830     _impl_.state_.Set("", GetArenaForAllocation());
831   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
832   if (from._internal_has_state()) {
833     _this->_impl_.state_.Set(from._internal_state(),
834       _this->GetArenaForAllocation());
835   }
836   _impl_.unique_session_name_.InitDefault();
837   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
838     _impl_.unique_session_name_.Set("", GetArenaForAllocation());
839   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
840   if (from._internal_has_unique_session_name()) {
841     _this->_impl_.unique_session_name_.Set(from._internal_unique_session_name(),
842       _this->GetArenaForAllocation());
843   }
844   _impl_.bugreport_filename_.InitDefault();
845   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
846     _impl_.bugreport_filename_.Set("", GetArenaForAllocation());
847   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
848   if (from._internal_has_bugreport_filename()) {
849     _this->_impl_.bugreport_filename_.Set(from._internal_bugreport_filename(),
850       _this->GetArenaForAllocation());
851   }
852   ::memcpy(&_impl_.id_, &from._impl_.id_,
853     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.is_started_) -
854     reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.is_started_));
855   // @@protoc_insertion_point(copy_constructor:perfetto.protos.TracingServiceState.TracingSession)
856 }
857 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)858 inline void TracingServiceState_TracingSession::SharedCtor(
859     ::_pb::Arena* arena, bool is_message_owned) {
860   (void)arena;
861   (void)is_message_owned;
862   new (&_impl_) Impl_{
863       decltype(_impl_._has_bits_){}
864     , /*decltype(_impl_._cached_size_)*/{}
865     , decltype(_impl_.buffer_size_kb_){arena}
866     , decltype(_impl_.state_){}
867     , decltype(_impl_.unique_session_name_){}
868     , decltype(_impl_.bugreport_filename_){}
869     , decltype(_impl_.id_){::uint64_t{0u}}
870     , decltype(_impl_.consumer_uid_){0}
871     , decltype(_impl_.duration_ms_){0u}
872     , decltype(_impl_.start_realtime_ns_){::int64_t{0}}
873     , decltype(_impl_.num_data_sources_){0u}
874     , decltype(_impl_.bugreport_score_){0}
875     , decltype(_impl_.is_started_){false}
876   };
877   _impl_.state_.InitDefault();
878   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
879     _impl_.state_.Set("", GetArenaForAllocation());
880   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
881   _impl_.unique_session_name_.InitDefault();
882   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
883     _impl_.unique_session_name_.Set("", GetArenaForAllocation());
884   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
885   _impl_.bugreport_filename_.InitDefault();
886   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
887     _impl_.bugreport_filename_.Set("", GetArenaForAllocation());
888   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
889 }
890 
~TracingServiceState_TracingSession()891 TracingServiceState_TracingSession::~TracingServiceState_TracingSession() {
892   // @@protoc_insertion_point(destructor:perfetto.protos.TracingServiceState.TracingSession)
893   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
894   (void)arena;
895     return;
896   }
897   SharedDtor();
898 }
899 
SharedDtor()900 inline void TracingServiceState_TracingSession::SharedDtor() {
901   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
902   _impl_.buffer_size_kb_.~RepeatedField();
903   _impl_.state_.Destroy();
904   _impl_.unique_session_name_.Destroy();
905   _impl_.bugreport_filename_.Destroy();
906 }
907 
SetCachedSize(int size) const908 void TracingServiceState_TracingSession::SetCachedSize(int size) const {
909   _impl_._cached_size_.Set(size);
910 }
911 
Clear()912 void TracingServiceState_TracingSession::Clear() {
913 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TracingServiceState.TracingSession)
914   ::uint32_t cached_has_bits = 0;
915   // Prevent compiler warnings about cached_has_bits being unused
916   (void) cached_has_bits;
917 
918   _impl_.buffer_size_kb_.Clear();
919   cached_has_bits = _impl_._has_bits_[0];
920   if (cached_has_bits & 0x00000007u) {
921     if (cached_has_bits & 0x00000001u) {
922       _impl_.state_.ClearNonDefaultToEmpty();
923     }
924     if (cached_has_bits & 0x00000002u) {
925       _impl_.unique_session_name_.ClearNonDefaultToEmpty();
926     }
927     if (cached_has_bits & 0x00000004u) {
928       _impl_.bugreport_filename_.ClearNonDefaultToEmpty();
929     }
930   }
931   if (cached_has_bits & 0x000000f8u) {
932     ::memset(&_impl_.id_, 0, static_cast<size_t>(
933         reinterpret_cast<char*>(&_impl_.num_data_sources_) -
934         reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.num_data_sources_));
935   }
936   if (cached_has_bits & 0x00000300u) {
937     ::memset(&_impl_.bugreport_score_, 0, static_cast<size_t>(
938         reinterpret_cast<char*>(&_impl_.is_started_) -
939         reinterpret_cast<char*>(&_impl_.bugreport_score_)) + sizeof(_impl_.is_started_));
940   }
941   _impl_._has_bits_.Clear();
942   _internal_metadata_.Clear<std::string>();
943 }
944 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)945 const char* TracingServiceState_TracingSession::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
946 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
947   _Internal::HasBits has_bits{};
948   while (!ctx->Done(&ptr)) {
949     ::uint32_t tag;
950     ptr = ::_pbi::ReadTag(ptr, &tag);
951     switch (tag >> 3) {
952       // optional uint64 id = 1;
953       case 1:
954         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
955           _Internal::set_has_id(&has_bits);
956           _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
957           CHK_(ptr);
958         } else {
959           goto handle_unusual;
960         }
961         continue;
962       // optional int32 consumer_uid = 2;
963       case 2:
964         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
965           _Internal::set_has_consumer_uid(&has_bits);
966           _impl_.consumer_uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
967           CHK_(ptr);
968         } else {
969           goto handle_unusual;
970         }
971         continue;
972       // optional string state = 3;
973       case 3:
974         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
975           auto str = _internal_mutable_state();
976           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
977           CHK_(ptr);
978         } else {
979           goto handle_unusual;
980         }
981         continue;
982       // optional string unique_session_name = 4;
983       case 4:
984         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
985           auto str = _internal_mutable_unique_session_name();
986           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
987           CHK_(ptr);
988         } else {
989           goto handle_unusual;
990         }
991         continue;
992       // repeated uint32 buffer_size_kb = 5;
993       case 5:
994         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
995           ptr -= 1;
996           do {
997             ptr += 1;
998             _internal_add_buffer_size_kb(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
999             CHK_(ptr);
1000             if (!ctx->DataAvailable(ptr)) break;
1001           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<40>(ptr));
1002         } else if (static_cast<::uint8_t>(tag) == 42) {
1003           ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_buffer_size_kb(), ptr, ctx);
1004           CHK_(ptr);
1005         } else {
1006           goto handle_unusual;
1007         }
1008         continue;
1009       // optional uint32 duration_ms = 6;
1010       case 6:
1011         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1012           _Internal::set_has_duration_ms(&has_bits);
1013           _impl_.duration_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1014           CHK_(ptr);
1015         } else {
1016           goto handle_unusual;
1017         }
1018         continue;
1019       // optional uint32 num_data_sources = 7;
1020       case 7:
1021         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1022           _Internal::set_has_num_data_sources(&has_bits);
1023           _impl_.num_data_sources_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1024           CHK_(ptr);
1025         } else {
1026           goto handle_unusual;
1027         }
1028         continue;
1029       // optional int64 start_realtime_ns = 8;
1030       case 8:
1031         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1032           _Internal::set_has_start_realtime_ns(&has_bits);
1033           _impl_.start_realtime_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1034           CHK_(ptr);
1035         } else {
1036           goto handle_unusual;
1037         }
1038         continue;
1039       // optional int32 bugreport_score = 9;
1040       case 9:
1041         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1042           _Internal::set_has_bugreport_score(&has_bits);
1043           _impl_.bugreport_score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1044           CHK_(ptr);
1045         } else {
1046           goto handle_unusual;
1047         }
1048         continue;
1049       // optional string bugreport_filename = 10;
1050       case 10:
1051         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
1052           auto str = _internal_mutable_bugreport_filename();
1053           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1054           CHK_(ptr);
1055         } else {
1056           goto handle_unusual;
1057         }
1058         continue;
1059       // optional bool is_started = 11;
1060       case 11:
1061         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1062           _Internal::set_has_is_started(&has_bits);
1063           _impl_.is_started_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1064           CHK_(ptr);
1065         } else {
1066           goto handle_unusual;
1067         }
1068         continue;
1069       default:
1070         goto handle_unusual;
1071     }  // switch
1072   handle_unusual:
1073     if ((tag == 0) || ((tag & 7) == 4)) {
1074       CHK_(ptr);
1075       ctx->SetLastTag(tag);
1076       goto message_done;
1077     }
1078     ptr = UnknownFieldParse(
1079         tag,
1080         _internal_metadata_.mutable_unknown_fields<std::string>(),
1081         ptr, ctx);
1082     CHK_(ptr != nullptr);
1083   }  // while
1084 message_done:
1085   _impl_._has_bits_.Or(has_bits);
1086   return ptr;
1087 failure:
1088   ptr = nullptr;
1089   goto message_done;
1090 #undef CHK_
1091 }
1092 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1093 ::uint8_t* TracingServiceState_TracingSession::_InternalSerialize(
1094     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1095   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TracingServiceState.TracingSession)
1096   ::uint32_t cached_has_bits = 0;
1097   (void) cached_has_bits;
1098 
1099   cached_has_bits = _impl_._has_bits_[0];
1100   // optional uint64 id = 1;
1101   if (cached_has_bits & 0x00000008u) {
1102     target = stream->EnsureSpace(target);
1103     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_id(), target);
1104   }
1105 
1106   // optional int32 consumer_uid = 2;
1107   if (cached_has_bits & 0x00000010u) {
1108     target = stream->EnsureSpace(target);
1109     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_consumer_uid(), target);
1110   }
1111 
1112   // optional string state = 3;
1113   if (cached_has_bits & 0x00000001u) {
1114     target = stream->WriteStringMaybeAliased(
1115         3, this->_internal_state(), target);
1116   }
1117 
1118   // optional string unique_session_name = 4;
1119   if (cached_has_bits & 0x00000002u) {
1120     target = stream->WriteStringMaybeAliased(
1121         4, this->_internal_unique_session_name(), target);
1122   }
1123 
1124   // repeated uint32 buffer_size_kb = 5;
1125   for (int i = 0, n = this->_internal_buffer_size_kb_size(); i < n; i++) {
1126     target = stream->EnsureSpace(target);
1127     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_buffer_size_kb(i), target);
1128   }
1129 
1130   // optional uint32 duration_ms = 6;
1131   if (cached_has_bits & 0x00000020u) {
1132     target = stream->EnsureSpace(target);
1133     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_duration_ms(), target);
1134   }
1135 
1136   // optional uint32 num_data_sources = 7;
1137   if (cached_has_bits & 0x00000080u) {
1138     target = stream->EnsureSpace(target);
1139     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_num_data_sources(), target);
1140   }
1141 
1142   // optional int64 start_realtime_ns = 8;
1143   if (cached_has_bits & 0x00000040u) {
1144     target = stream->EnsureSpace(target);
1145     target = ::_pbi::WireFormatLite::WriteInt64ToArray(8, this->_internal_start_realtime_ns(), target);
1146   }
1147 
1148   // optional int32 bugreport_score = 9;
1149   if (cached_has_bits & 0x00000100u) {
1150     target = stream->EnsureSpace(target);
1151     target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_bugreport_score(), target);
1152   }
1153 
1154   // optional string bugreport_filename = 10;
1155   if (cached_has_bits & 0x00000004u) {
1156     target = stream->WriteStringMaybeAliased(
1157         10, this->_internal_bugreport_filename(), target);
1158   }
1159 
1160   // optional bool is_started = 11;
1161   if (cached_has_bits & 0x00000200u) {
1162     target = stream->EnsureSpace(target);
1163     target = ::_pbi::WireFormatLite::WriteBoolToArray(11, this->_internal_is_started(), target);
1164   }
1165 
1166   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1167     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1168         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1169   }
1170   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TracingServiceState.TracingSession)
1171   return target;
1172 }
1173 
ByteSizeLong() const1174 size_t TracingServiceState_TracingSession::ByteSizeLong() const {
1175 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TracingServiceState.TracingSession)
1176   size_t total_size = 0;
1177 
1178   ::uint32_t cached_has_bits = 0;
1179   // Prevent compiler warnings about cached_has_bits being unused
1180   (void) cached_has_bits;
1181 
1182   // repeated uint32 buffer_size_kb = 5;
1183   {
1184     size_t data_size = ::_pbi::WireFormatLite::
1185       UInt32Size(this->_impl_.buffer_size_kb_);
1186     total_size += 1 *
1187                   ::_pbi::FromIntSize(this->_internal_buffer_size_kb_size());
1188     total_size += data_size;
1189   }
1190 
1191   cached_has_bits = _impl_._has_bits_[0];
1192   if (cached_has_bits & 0x000000ffu) {
1193     // optional string state = 3;
1194     if (cached_has_bits & 0x00000001u) {
1195       total_size += 1 +
1196         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1197           this->_internal_state());
1198     }
1199 
1200     // optional string unique_session_name = 4;
1201     if (cached_has_bits & 0x00000002u) {
1202       total_size += 1 +
1203         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1204           this->_internal_unique_session_name());
1205     }
1206 
1207     // optional string bugreport_filename = 10;
1208     if (cached_has_bits & 0x00000004u) {
1209       total_size += 1 +
1210         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1211           this->_internal_bugreport_filename());
1212     }
1213 
1214     // optional uint64 id = 1;
1215     if (cached_has_bits & 0x00000008u) {
1216       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_id());
1217     }
1218 
1219     // optional int32 consumer_uid = 2;
1220     if (cached_has_bits & 0x00000010u) {
1221       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_consumer_uid());
1222     }
1223 
1224     // optional uint32 duration_ms = 6;
1225     if (cached_has_bits & 0x00000020u) {
1226       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_duration_ms());
1227     }
1228 
1229     // optional int64 start_realtime_ns = 8;
1230     if (cached_has_bits & 0x00000040u) {
1231       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_start_realtime_ns());
1232     }
1233 
1234     // optional uint32 num_data_sources = 7;
1235     if (cached_has_bits & 0x00000080u) {
1236       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_num_data_sources());
1237     }
1238 
1239   }
1240   if (cached_has_bits & 0x00000300u) {
1241     // optional int32 bugreport_score = 9;
1242     if (cached_has_bits & 0x00000100u) {
1243       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_bugreport_score());
1244     }
1245 
1246     // optional bool is_started = 11;
1247     if (cached_has_bits & 0x00000200u) {
1248       total_size += 1 + 1;
1249     }
1250 
1251   }
1252   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1253     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1254   }
1255   int cached_size = ::_pbi::ToCachedSize(total_size);
1256   SetCachedSize(cached_size);
1257   return total_size;
1258 }
1259 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1260 void TracingServiceState_TracingSession::CheckTypeAndMergeFrom(
1261     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1262   MergeFrom(*::_pbi::DownCast<const TracingServiceState_TracingSession*>(
1263       &from));
1264 }
1265 
MergeFrom(const TracingServiceState_TracingSession & from)1266 void TracingServiceState_TracingSession::MergeFrom(const TracingServiceState_TracingSession& from) {
1267   TracingServiceState_TracingSession* const _this = this;
1268   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TracingServiceState.TracingSession)
1269   GOOGLE_DCHECK_NE(&from, _this);
1270   ::uint32_t cached_has_bits = 0;
1271   (void) cached_has_bits;
1272 
1273   _this->_impl_.buffer_size_kb_.MergeFrom(from._impl_.buffer_size_kb_);
1274   cached_has_bits = from._impl_._has_bits_[0];
1275   if (cached_has_bits & 0x000000ffu) {
1276     if (cached_has_bits & 0x00000001u) {
1277       _this->_internal_set_state(from._internal_state());
1278     }
1279     if (cached_has_bits & 0x00000002u) {
1280       _this->_internal_set_unique_session_name(from._internal_unique_session_name());
1281     }
1282     if (cached_has_bits & 0x00000004u) {
1283       _this->_internal_set_bugreport_filename(from._internal_bugreport_filename());
1284     }
1285     if (cached_has_bits & 0x00000008u) {
1286       _this->_impl_.id_ = from._impl_.id_;
1287     }
1288     if (cached_has_bits & 0x00000010u) {
1289       _this->_impl_.consumer_uid_ = from._impl_.consumer_uid_;
1290     }
1291     if (cached_has_bits & 0x00000020u) {
1292       _this->_impl_.duration_ms_ = from._impl_.duration_ms_;
1293     }
1294     if (cached_has_bits & 0x00000040u) {
1295       _this->_impl_.start_realtime_ns_ = from._impl_.start_realtime_ns_;
1296     }
1297     if (cached_has_bits & 0x00000080u) {
1298       _this->_impl_.num_data_sources_ = from._impl_.num_data_sources_;
1299     }
1300     _this->_impl_._has_bits_[0] |= cached_has_bits;
1301   }
1302   if (cached_has_bits & 0x00000300u) {
1303     if (cached_has_bits & 0x00000100u) {
1304       _this->_impl_.bugreport_score_ = from._impl_.bugreport_score_;
1305     }
1306     if (cached_has_bits & 0x00000200u) {
1307       _this->_impl_.is_started_ = from._impl_.is_started_;
1308     }
1309     _this->_impl_._has_bits_[0] |= cached_has_bits;
1310   }
1311   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1312 }
1313 
CopyFrom(const TracingServiceState_TracingSession & from)1314 void TracingServiceState_TracingSession::CopyFrom(const TracingServiceState_TracingSession& from) {
1315 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TracingServiceState.TracingSession)
1316   if (&from == this) return;
1317   Clear();
1318   MergeFrom(from);
1319 }
1320 
IsInitialized() const1321 bool TracingServiceState_TracingSession::IsInitialized() const {
1322   return true;
1323 }
1324 
InternalSwap(TracingServiceState_TracingSession * other)1325 void TracingServiceState_TracingSession::InternalSwap(TracingServiceState_TracingSession* other) {
1326   using std::swap;
1327   auto* lhs_arena = GetArenaForAllocation();
1328   auto* rhs_arena = other->GetArenaForAllocation();
1329   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1330   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1331   _impl_.buffer_size_kb_.InternalSwap(&other->_impl_.buffer_size_kb_);
1332   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1333       &_impl_.state_, lhs_arena,
1334       &other->_impl_.state_, rhs_arena
1335   );
1336   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1337       &_impl_.unique_session_name_, lhs_arena,
1338       &other->_impl_.unique_session_name_, rhs_arena
1339   );
1340   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1341       &_impl_.bugreport_filename_, lhs_arena,
1342       &other->_impl_.bugreport_filename_, rhs_arena
1343   );
1344   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1345       PROTOBUF_FIELD_OFFSET(TracingServiceState_TracingSession, _impl_.is_started_)
1346       + sizeof(TracingServiceState_TracingSession::_impl_.is_started_)  // NOLINT
1347       - PROTOBUF_FIELD_OFFSET(TracingServiceState_TracingSession, _impl_.id_)>(
1348           reinterpret_cast<char*>(&_impl_.id_),
1349           reinterpret_cast<char*>(&other->_impl_.id_));
1350 }
1351 
GetTypeName() const1352 std::string TracingServiceState_TracingSession::GetTypeName() const {
1353   return "perfetto.protos.TracingServiceState.TracingSession";
1354 }
1355 
1356 
1357 // ===================================================================
1358 
1359 class TracingServiceState::_Internal {
1360  public:
1361   using HasBits = decltype(std::declval<TracingServiceState>()._impl_._has_bits_);
set_has_supports_tracing_sessions(HasBits * has_bits)1362   static void set_has_supports_tracing_sessions(HasBits* has_bits) {
1363     (*has_bits)[0] |= 8u;
1364   }
set_has_num_sessions(HasBits * has_bits)1365   static void set_has_num_sessions(HasBits* has_bits) {
1366     (*has_bits)[0] |= 2u;
1367   }
set_has_num_sessions_started(HasBits * has_bits)1368   static void set_has_num_sessions_started(HasBits* has_bits) {
1369     (*has_bits)[0] |= 4u;
1370   }
set_has_tracing_service_version(HasBits * has_bits)1371   static void set_has_tracing_service_version(HasBits* has_bits) {
1372     (*has_bits)[0] |= 1u;
1373   }
1374 };
1375 
TracingServiceState(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1376 TracingServiceState::TracingServiceState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1377                          bool is_message_owned)
1378   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1379   SharedCtor(arena, is_message_owned);
1380   // @@protoc_insertion_point(arena_constructor:perfetto.protos.TracingServiceState)
1381 }
TracingServiceState(const TracingServiceState & from)1382 TracingServiceState::TracingServiceState(const TracingServiceState& from)
1383   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1384   TracingServiceState* const _this = this; (void)_this;
1385   new (&_impl_) Impl_{
1386       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1387     , /*decltype(_impl_._cached_size_)*/{}
1388     , decltype(_impl_.producers_){from._impl_.producers_}
1389     , decltype(_impl_.data_sources_){from._impl_.data_sources_}
1390     , decltype(_impl_.tracing_sessions_){from._impl_.tracing_sessions_}
1391     , decltype(_impl_.tracing_service_version_){}
1392     , decltype(_impl_.num_sessions_){}
1393     , decltype(_impl_.num_sessions_started_){}
1394     , decltype(_impl_.supports_tracing_sessions_){}};
1395 
1396   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1397   _impl_.tracing_service_version_.InitDefault();
1398   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1399     _impl_.tracing_service_version_.Set("", GetArenaForAllocation());
1400   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1401   if (from._internal_has_tracing_service_version()) {
1402     _this->_impl_.tracing_service_version_.Set(from._internal_tracing_service_version(),
1403       _this->GetArenaForAllocation());
1404   }
1405   ::memcpy(&_impl_.num_sessions_, &from._impl_.num_sessions_,
1406     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.supports_tracing_sessions_) -
1407     reinterpret_cast<char*>(&_impl_.num_sessions_)) + sizeof(_impl_.supports_tracing_sessions_));
1408   // @@protoc_insertion_point(copy_constructor:perfetto.protos.TracingServiceState)
1409 }
1410 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1411 inline void TracingServiceState::SharedCtor(
1412     ::_pb::Arena* arena, bool is_message_owned) {
1413   (void)arena;
1414   (void)is_message_owned;
1415   new (&_impl_) Impl_{
1416       decltype(_impl_._has_bits_){}
1417     , /*decltype(_impl_._cached_size_)*/{}
1418     , decltype(_impl_.producers_){arena}
1419     , decltype(_impl_.data_sources_){arena}
1420     , decltype(_impl_.tracing_sessions_){arena}
1421     , decltype(_impl_.tracing_service_version_){}
1422     , decltype(_impl_.num_sessions_){0}
1423     , decltype(_impl_.num_sessions_started_){0}
1424     , decltype(_impl_.supports_tracing_sessions_){false}
1425   };
1426   _impl_.tracing_service_version_.InitDefault();
1427   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1428     _impl_.tracing_service_version_.Set("", GetArenaForAllocation());
1429   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1430 }
1431 
~TracingServiceState()1432 TracingServiceState::~TracingServiceState() {
1433   // @@protoc_insertion_point(destructor:perfetto.protos.TracingServiceState)
1434   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1435   (void)arena;
1436     return;
1437   }
1438   SharedDtor();
1439 }
1440 
SharedDtor()1441 inline void TracingServiceState::SharedDtor() {
1442   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1443   _impl_.producers_.~RepeatedPtrField();
1444   _impl_.data_sources_.~RepeatedPtrField();
1445   _impl_.tracing_sessions_.~RepeatedPtrField();
1446   _impl_.tracing_service_version_.Destroy();
1447 }
1448 
SetCachedSize(int size) const1449 void TracingServiceState::SetCachedSize(int size) const {
1450   _impl_._cached_size_.Set(size);
1451 }
1452 
Clear()1453 void TracingServiceState::Clear() {
1454 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TracingServiceState)
1455   ::uint32_t cached_has_bits = 0;
1456   // Prevent compiler warnings about cached_has_bits being unused
1457   (void) cached_has_bits;
1458 
1459   _impl_.producers_.Clear();
1460   _impl_.data_sources_.Clear();
1461   _impl_.tracing_sessions_.Clear();
1462   cached_has_bits = _impl_._has_bits_[0];
1463   if (cached_has_bits & 0x00000001u) {
1464     _impl_.tracing_service_version_.ClearNonDefaultToEmpty();
1465   }
1466   if (cached_has_bits & 0x0000000eu) {
1467     ::memset(&_impl_.num_sessions_, 0, static_cast<size_t>(
1468         reinterpret_cast<char*>(&_impl_.supports_tracing_sessions_) -
1469         reinterpret_cast<char*>(&_impl_.num_sessions_)) + sizeof(_impl_.supports_tracing_sessions_));
1470   }
1471   _impl_._has_bits_.Clear();
1472   _internal_metadata_.Clear<std::string>();
1473 }
1474 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1475 const char* TracingServiceState::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1476 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1477   _Internal::HasBits has_bits{};
1478   while (!ctx->Done(&ptr)) {
1479     ::uint32_t tag;
1480     ptr = ::_pbi::ReadTag(ptr, &tag);
1481     switch (tag >> 3) {
1482       // repeated .perfetto.protos.TracingServiceState.Producer producers = 1;
1483       case 1:
1484         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1485           ptr -= 1;
1486           do {
1487             ptr += 1;
1488             ptr = ctx->ParseMessage(_internal_add_producers(), ptr);
1489             CHK_(ptr);
1490             if (!ctx->DataAvailable(ptr)) break;
1491           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1492         } else {
1493           goto handle_unusual;
1494         }
1495         continue;
1496       // repeated .perfetto.protos.TracingServiceState.DataSource data_sources = 2;
1497       case 2:
1498         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1499           ptr -= 1;
1500           do {
1501             ptr += 1;
1502             ptr = ctx->ParseMessage(_internal_add_data_sources(), ptr);
1503             CHK_(ptr);
1504             if (!ctx->DataAvailable(ptr)) break;
1505           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
1506         } else {
1507           goto handle_unusual;
1508         }
1509         continue;
1510       // optional int32 num_sessions = 3;
1511       case 3:
1512         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1513           _Internal::set_has_num_sessions(&has_bits);
1514           _impl_.num_sessions_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1515           CHK_(ptr);
1516         } else {
1517           goto handle_unusual;
1518         }
1519         continue;
1520       // optional int32 num_sessions_started = 4;
1521       case 4:
1522         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1523           _Internal::set_has_num_sessions_started(&has_bits);
1524           _impl_.num_sessions_started_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1525           CHK_(ptr);
1526         } else {
1527           goto handle_unusual;
1528         }
1529         continue;
1530       // optional string tracing_service_version = 5;
1531       case 5:
1532         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
1533           auto str = _internal_mutable_tracing_service_version();
1534           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1535           CHK_(ptr);
1536         } else {
1537           goto handle_unusual;
1538         }
1539         continue;
1540       // repeated .perfetto.protos.TracingServiceState.TracingSession tracing_sessions = 6;
1541       case 6:
1542         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
1543           ptr -= 1;
1544           do {
1545             ptr += 1;
1546             ptr = ctx->ParseMessage(_internal_add_tracing_sessions(), ptr);
1547             CHK_(ptr);
1548             if (!ctx->DataAvailable(ptr)) break;
1549           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<50>(ptr));
1550         } else {
1551           goto handle_unusual;
1552         }
1553         continue;
1554       // optional bool supports_tracing_sessions = 7;
1555       case 7:
1556         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1557           _Internal::set_has_supports_tracing_sessions(&has_bits);
1558           _impl_.supports_tracing_sessions_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1559           CHK_(ptr);
1560         } else {
1561           goto handle_unusual;
1562         }
1563         continue;
1564       default:
1565         goto handle_unusual;
1566     }  // switch
1567   handle_unusual:
1568     if ((tag == 0) || ((tag & 7) == 4)) {
1569       CHK_(ptr);
1570       ctx->SetLastTag(tag);
1571       goto message_done;
1572     }
1573     ptr = UnknownFieldParse(
1574         tag,
1575         _internal_metadata_.mutable_unknown_fields<std::string>(),
1576         ptr, ctx);
1577     CHK_(ptr != nullptr);
1578   }  // while
1579 message_done:
1580   _impl_._has_bits_.Or(has_bits);
1581   return ptr;
1582 failure:
1583   ptr = nullptr;
1584   goto message_done;
1585 #undef CHK_
1586 }
1587 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1588 ::uint8_t* TracingServiceState::_InternalSerialize(
1589     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1590   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TracingServiceState)
1591   ::uint32_t cached_has_bits = 0;
1592   (void) cached_has_bits;
1593 
1594   // repeated .perfetto.protos.TracingServiceState.Producer producers = 1;
1595   for (unsigned i = 0,
1596       n = static_cast<unsigned>(this->_internal_producers_size()); i < n; i++) {
1597     const auto& repfield = this->_internal_producers(i);
1598     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1599         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1600   }
1601 
1602   // repeated .perfetto.protos.TracingServiceState.DataSource data_sources = 2;
1603   for (unsigned i = 0,
1604       n = static_cast<unsigned>(this->_internal_data_sources_size()); i < n; i++) {
1605     const auto& repfield = this->_internal_data_sources(i);
1606     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1607         InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
1608   }
1609 
1610   cached_has_bits = _impl_._has_bits_[0];
1611   // optional int32 num_sessions = 3;
1612   if (cached_has_bits & 0x00000002u) {
1613     target = stream->EnsureSpace(target);
1614     target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_num_sessions(), target);
1615   }
1616 
1617   // optional int32 num_sessions_started = 4;
1618   if (cached_has_bits & 0x00000004u) {
1619     target = stream->EnsureSpace(target);
1620     target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_num_sessions_started(), target);
1621   }
1622 
1623   // optional string tracing_service_version = 5;
1624   if (cached_has_bits & 0x00000001u) {
1625     target = stream->WriteStringMaybeAliased(
1626         5, this->_internal_tracing_service_version(), target);
1627   }
1628 
1629   // repeated .perfetto.protos.TracingServiceState.TracingSession tracing_sessions = 6;
1630   for (unsigned i = 0,
1631       n = static_cast<unsigned>(this->_internal_tracing_sessions_size()); i < n; i++) {
1632     const auto& repfield = this->_internal_tracing_sessions(i);
1633     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1634         InternalWriteMessage(6, repfield, repfield.GetCachedSize(), target, stream);
1635   }
1636 
1637   // optional bool supports_tracing_sessions = 7;
1638   if (cached_has_bits & 0x00000008u) {
1639     target = stream->EnsureSpace(target);
1640     target = ::_pbi::WireFormatLite::WriteBoolToArray(7, this->_internal_supports_tracing_sessions(), target);
1641   }
1642 
1643   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1644     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1645         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1646   }
1647   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TracingServiceState)
1648   return target;
1649 }
1650 
ByteSizeLong() const1651 size_t TracingServiceState::ByteSizeLong() const {
1652 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TracingServiceState)
1653   size_t total_size = 0;
1654 
1655   ::uint32_t cached_has_bits = 0;
1656   // Prevent compiler warnings about cached_has_bits being unused
1657   (void) cached_has_bits;
1658 
1659   // repeated .perfetto.protos.TracingServiceState.Producer producers = 1;
1660   total_size += 1UL * this->_internal_producers_size();
1661   for (const auto& msg : this->_impl_.producers_) {
1662     total_size +=
1663       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1664   }
1665 
1666   // repeated .perfetto.protos.TracingServiceState.DataSource data_sources = 2;
1667   total_size += 1UL * this->_internal_data_sources_size();
1668   for (const auto& msg : this->_impl_.data_sources_) {
1669     total_size +=
1670       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1671   }
1672 
1673   // repeated .perfetto.protos.TracingServiceState.TracingSession tracing_sessions = 6;
1674   total_size += 1UL * this->_internal_tracing_sessions_size();
1675   for (const auto& msg : this->_impl_.tracing_sessions_) {
1676     total_size +=
1677       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1678   }
1679 
1680   cached_has_bits = _impl_._has_bits_[0];
1681   if (cached_has_bits & 0x0000000fu) {
1682     // optional string tracing_service_version = 5;
1683     if (cached_has_bits & 0x00000001u) {
1684       total_size += 1 +
1685         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1686           this->_internal_tracing_service_version());
1687     }
1688 
1689     // optional int32 num_sessions = 3;
1690     if (cached_has_bits & 0x00000002u) {
1691       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_sessions());
1692     }
1693 
1694     // optional int32 num_sessions_started = 4;
1695     if (cached_has_bits & 0x00000004u) {
1696       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_num_sessions_started());
1697     }
1698 
1699     // optional bool supports_tracing_sessions = 7;
1700     if (cached_has_bits & 0x00000008u) {
1701       total_size += 1 + 1;
1702     }
1703 
1704   }
1705   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1706     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1707   }
1708   int cached_size = ::_pbi::ToCachedSize(total_size);
1709   SetCachedSize(cached_size);
1710   return total_size;
1711 }
1712 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1713 void TracingServiceState::CheckTypeAndMergeFrom(
1714     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1715   MergeFrom(*::_pbi::DownCast<const TracingServiceState*>(
1716       &from));
1717 }
1718 
MergeFrom(const TracingServiceState & from)1719 void TracingServiceState::MergeFrom(const TracingServiceState& from) {
1720   TracingServiceState* const _this = this;
1721   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TracingServiceState)
1722   GOOGLE_DCHECK_NE(&from, _this);
1723   ::uint32_t cached_has_bits = 0;
1724   (void) cached_has_bits;
1725 
1726   _this->_impl_.producers_.MergeFrom(from._impl_.producers_);
1727   _this->_impl_.data_sources_.MergeFrom(from._impl_.data_sources_);
1728   _this->_impl_.tracing_sessions_.MergeFrom(from._impl_.tracing_sessions_);
1729   cached_has_bits = from._impl_._has_bits_[0];
1730   if (cached_has_bits & 0x0000000fu) {
1731     if (cached_has_bits & 0x00000001u) {
1732       _this->_internal_set_tracing_service_version(from._internal_tracing_service_version());
1733     }
1734     if (cached_has_bits & 0x00000002u) {
1735       _this->_impl_.num_sessions_ = from._impl_.num_sessions_;
1736     }
1737     if (cached_has_bits & 0x00000004u) {
1738       _this->_impl_.num_sessions_started_ = from._impl_.num_sessions_started_;
1739     }
1740     if (cached_has_bits & 0x00000008u) {
1741       _this->_impl_.supports_tracing_sessions_ = from._impl_.supports_tracing_sessions_;
1742     }
1743     _this->_impl_._has_bits_[0] |= cached_has_bits;
1744   }
1745   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1746 }
1747 
CopyFrom(const TracingServiceState & from)1748 void TracingServiceState::CopyFrom(const TracingServiceState& from) {
1749 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TracingServiceState)
1750   if (&from == this) return;
1751   Clear();
1752   MergeFrom(from);
1753 }
1754 
IsInitialized() const1755 bool TracingServiceState::IsInitialized() const {
1756   return true;
1757 }
1758 
InternalSwap(TracingServiceState * other)1759 void TracingServiceState::InternalSwap(TracingServiceState* other) {
1760   using std::swap;
1761   auto* lhs_arena = GetArenaForAllocation();
1762   auto* rhs_arena = other->GetArenaForAllocation();
1763   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1764   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1765   _impl_.producers_.InternalSwap(&other->_impl_.producers_);
1766   _impl_.data_sources_.InternalSwap(&other->_impl_.data_sources_);
1767   _impl_.tracing_sessions_.InternalSwap(&other->_impl_.tracing_sessions_);
1768   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1769       &_impl_.tracing_service_version_, lhs_arena,
1770       &other->_impl_.tracing_service_version_, rhs_arena
1771   );
1772   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1773       PROTOBUF_FIELD_OFFSET(TracingServiceState, _impl_.supports_tracing_sessions_)
1774       + sizeof(TracingServiceState::_impl_.supports_tracing_sessions_)  // NOLINT
1775       - PROTOBUF_FIELD_OFFSET(TracingServiceState, _impl_.num_sessions_)>(
1776           reinterpret_cast<char*>(&_impl_.num_sessions_),
1777           reinterpret_cast<char*>(&other->_impl_.num_sessions_));
1778 }
1779 
GetTypeName() const1780 std::string TracingServiceState::GetTypeName() const {
1781   return "perfetto.protos.TracingServiceState";
1782 }
1783 
1784 
1785 // @@protoc_insertion_point(namespace_scope)
1786 }  // namespace protos
1787 }  // namespace perfetto
1788 PROTOBUF_NAMESPACE_OPEN
1789 template<> PROTOBUF_NOINLINE ::perfetto::protos::TracingServiceState_Producer*
CreateMaybeMessage(Arena * arena)1790 Arena::CreateMaybeMessage< ::perfetto::protos::TracingServiceState_Producer >(Arena* arena) {
1791   return Arena::CreateMessageInternal< ::perfetto::protos::TracingServiceState_Producer >(arena);
1792 }
1793 template<> PROTOBUF_NOINLINE ::perfetto::protos::TracingServiceState_DataSource*
CreateMaybeMessage(Arena * arena)1794 Arena::CreateMaybeMessage< ::perfetto::protos::TracingServiceState_DataSource >(Arena* arena) {
1795   return Arena::CreateMessageInternal< ::perfetto::protos::TracingServiceState_DataSource >(arena);
1796 }
1797 template<> PROTOBUF_NOINLINE ::perfetto::protos::TracingServiceState_TracingSession*
CreateMaybeMessage(Arena * arena)1798 Arena::CreateMaybeMessage< ::perfetto::protos::TracingServiceState_TracingSession >(Arena* arena) {
1799   return Arena::CreateMessageInternal< ::perfetto::protos::TracingServiceState_TracingSession >(arena);
1800 }
1801 template<> PROTOBUF_NOINLINE ::perfetto::protos::TracingServiceState*
CreateMaybeMessage(Arena * arena)1802 Arena::CreateMaybeMessage< ::perfetto::protos::TracingServiceState >(Arena* arena) {
1803   return Arena::CreateMessageInternal< ::perfetto::protos::TracingServiceState >(arena);
1804 }
1805 PROTOBUF_NAMESPACE_CLOSE
1806 
1807 // @@protoc_insertion_point(global_scope)
1808 #include <google/protobuf/port_undef.inc>
1809