1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/common/observable_events.proto
3 
4 #include "protos/perfetto/common/observable_events.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 {
ObservableEvents_DataSourceInstanceStateChange(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.producer_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.data_source_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.state_)*/1} {}
30 struct ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternal {
ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternalperfetto::protos::ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternal31   PROTOBUF_CONSTEXPR ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternal()
32       : _instance(::_pbi::ConstantInitialized{}) {}
~ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternalperfetto::protos::ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternal33   ~ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternal() {}
34   union {  // NOLINT(misc-non-private-member-variables-in-classes)
35     ObservableEvents_DataSourceInstanceStateChange _instance;
36   };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ObservableEvents_DataSourceInstanceStateChangeDefaultTypeInternal _ObservableEvents_DataSourceInstanceStateChange_default_instance_;
ObservableEvents_CloneTriggerHit(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR ObservableEvents_CloneTriggerHit::ObservableEvents_CloneTriggerHit(
40     ::_pbi::ConstantInitialized): _impl_{
41     /*decltype(_impl_._has_bits_)*/{}
42   , /*decltype(_impl_._cached_size_)*/{}
43   , /*decltype(_impl_.trigger_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
44   , /*decltype(_impl_.producer_name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
45   , /*decltype(_impl_.tracing_session_id_)*/::int64_t{0}
46   , /*decltype(_impl_.boot_time_ns_)*/::uint64_t{0u}
47   , /*decltype(_impl_.producer_uid_)*/0u} {}
48 struct ObservableEvents_CloneTriggerHitDefaultTypeInternal {
ObservableEvents_CloneTriggerHitDefaultTypeInternalperfetto::protos::ObservableEvents_CloneTriggerHitDefaultTypeInternal49   PROTOBUF_CONSTEXPR ObservableEvents_CloneTriggerHitDefaultTypeInternal()
50       : _instance(::_pbi::ConstantInitialized{}) {}
~ObservableEvents_CloneTriggerHitDefaultTypeInternalperfetto::protos::ObservableEvents_CloneTriggerHitDefaultTypeInternal51   ~ObservableEvents_CloneTriggerHitDefaultTypeInternal() {}
52   union {  // NOLINT(misc-non-private-member-variables-in-classes)
53     ObservableEvents_CloneTriggerHit _instance;
54   };
55 };
56 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ObservableEvents_CloneTriggerHitDefaultTypeInternal _ObservableEvents_CloneTriggerHit_default_instance_;
ObservableEvents(::_pbi::ConstantInitialized)57 PROTOBUF_CONSTEXPR ObservableEvents::ObservableEvents(
58     ::_pbi::ConstantInitialized): _impl_{
59     /*decltype(_impl_._has_bits_)*/{}
60   , /*decltype(_impl_._cached_size_)*/{}
61   , /*decltype(_impl_.instance_state_changes_)*/{}
62   , /*decltype(_impl_.clone_trigger_hit_)*/nullptr
63   , /*decltype(_impl_.all_data_sources_started_)*/false} {}
64 struct ObservableEventsDefaultTypeInternal {
ObservableEventsDefaultTypeInternalperfetto::protos::ObservableEventsDefaultTypeInternal65   PROTOBUF_CONSTEXPR ObservableEventsDefaultTypeInternal()
66       : _instance(::_pbi::ConstantInitialized{}) {}
~ObservableEventsDefaultTypeInternalperfetto::protos::ObservableEventsDefaultTypeInternal67   ~ObservableEventsDefaultTypeInternal() {}
68   union {  // NOLINT(misc-non-private-member-variables-in-classes)
69     ObservableEvents _instance;
70   };
71 };
72 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ObservableEventsDefaultTypeInternal _ObservableEvents_default_instance_;
73 }  // namespace protos
74 }  // namespace perfetto
75 namespace perfetto {
76 namespace protos {
ObservableEvents_Type_IsValid(int value)77 bool ObservableEvents_Type_IsValid(int value) {
78   switch (value) {
79     case 0:
80     case 1:
81     case 2:
82     case 4:
83       return true;
84     default:
85       return false;
86   }
87 }
88 
89 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ObservableEvents_Type_strings[4] = {};
90 
91 static const char ObservableEvents_Type_names[] =
92   "TYPE_ALL_DATA_SOURCES_STARTED"
93   "TYPE_CLONE_TRIGGER_HIT"
94   "TYPE_DATA_SOURCES_INSTANCES"
95   "TYPE_UNSPECIFIED";
96 
97 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ObservableEvents_Type_entries[] = {
98   { {ObservableEvents_Type_names + 0, 29}, 2 },
99   { {ObservableEvents_Type_names + 29, 22}, 4 },
100   { {ObservableEvents_Type_names + 51, 27}, 1 },
101   { {ObservableEvents_Type_names + 78, 16}, 0 },
102 };
103 
104 static const int ObservableEvents_Type_entries_by_number[] = {
105   3, // 0 -> TYPE_UNSPECIFIED
106   2, // 1 -> TYPE_DATA_SOURCES_INSTANCES
107   0, // 2 -> TYPE_ALL_DATA_SOURCES_STARTED
108   1, // 4 -> TYPE_CLONE_TRIGGER_HIT
109 };
110 
ObservableEvents_Type_Name(ObservableEvents_Type value)111 const std::string& ObservableEvents_Type_Name(
112     ObservableEvents_Type value) {
113   static const bool dummy =
114       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
115           ObservableEvents_Type_entries,
116           ObservableEvents_Type_entries_by_number,
117           4, ObservableEvents_Type_strings);
118   (void) dummy;
119   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
120       ObservableEvents_Type_entries,
121       ObservableEvents_Type_entries_by_number,
122       4, value);
123   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
124                      ObservableEvents_Type_strings[idx].get();
125 }
ObservableEvents_Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ObservableEvents_Type * value)126 bool ObservableEvents_Type_Parse(
127     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObservableEvents_Type* value) {
128   int int_value;
129   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
130       ObservableEvents_Type_entries, 4, name, &int_value);
131   if (success) {
132     *value = static_cast<ObservableEvents_Type>(int_value);
133   }
134   return success;
135 }
136 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
137 constexpr ObservableEvents_Type ObservableEvents::TYPE_UNSPECIFIED;
138 constexpr ObservableEvents_Type ObservableEvents::TYPE_DATA_SOURCES_INSTANCES;
139 constexpr ObservableEvents_Type ObservableEvents::TYPE_ALL_DATA_SOURCES_STARTED;
140 constexpr ObservableEvents_Type ObservableEvents::TYPE_CLONE_TRIGGER_HIT;
141 constexpr ObservableEvents_Type ObservableEvents::Type_MIN;
142 constexpr ObservableEvents_Type ObservableEvents::Type_MAX;
143 constexpr int ObservableEvents::Type_ARRAYSIZE;
144 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
ObservableEvents_DataSourceInstanceState_IsValid(int value)145 bool ObservableEvents_DataSourceInstanceState_IsValid(int value) {
146   switch (value) {
147     case 1:
148     case 2:
149       return true;
150     default:
151       return false;
152   }
153 }
154 
155 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> ObservableEvents_DataSourceInstanceState_strings[2] = {};
156 
157 static const char ObservableEvents_DataSourceInstanceState_names[] =
158   "DATA_SOURCE_INSTANCE_STATE_STARTED"
159   "DATA_SOURCE_INSTANCE_STATE_STOPPED";
160 
161 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry ObservableEvents_DataSourceInstanceState_entries[] = {
162   { {ObservableEvents_DataSourceInstanceState_names + 0, 34}, 2 },
163   { {ObservableEvents_DataSourceInstanceState_names + 34, 34}, 1 },
164 };
165 
166 static const int ObservableEvents_DataSourceInstanceState_entries_by_number[] = {
167   1, // 1 -> DATA_SOURCE_INSTANCE_STATE_STOPPED
168   0, // 2 -> DATA_SOURCE_INSTANCE_STATE_STARTED
169 };
170 
ObservableEvents_DataSourceInstanceState_Name(ObservableEvents_DataSourceInstanceState value)171 const std::string& ObservableEvents_DataSourceInstanceState_Name(
172     ObservableEvents_DataSourceInstanceState value) {
173   static const bool dummy =
174       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
175           ObservableEvents_DataSourceInstanceState_entries,
176           ObservableEvents_DataSourceInstanceState_entries_by_number,
177           2, ObservableEvents_DataSourceInstanceState_strings);
178   (void) dummy;
179   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
180       ObservableEvents_DataSourceInstanceState_entries,
181       ObservableEvents_DataSourceInstanceState_entries_by_number,
182       2, value);
183   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
184                      ObservableEvents_DataSourceInstanceState_strings[idx].get();
185 }
ObservableEvents_DataSourceInstanceState_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,ObservableEvents_DataSourceInstanceState * value)186 bool ObservableEvents_DataSourceInstanceState_Parse(
187     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ObservableEvents_DataSourceInstanceState* value) {
188   int int_value;
189   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
190       ObservableEvents_DataSourceInstanceState_entries, 2, name, &int_value);
191   if (success) {
192     *value = static_cast<ObservableEvents_DataSourceInstanceState>(int_value);
193   }
194   return success;
195 }
196 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
197 constexpr ObservableEvents_DataSourceInstanceState ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STOPPED;
198 constexpr ObservableEvents_DataSourceInstanceState ObservableEvents::DATA_SOURCE_INSTANCE_STATE_STARTED;
199 constexpr ObservableEvents_DataSourceInstanceState ObservableEvents::DataSourceInstanceState_MIN;
200 constexpr ObservableEvents_DataSourceInstanceState ObservableEvents::DataSourceInstanceState_MAX;
201 constexpr int ObservableEvents::DataSourceInstanceState_ARRAYSIZE;
202 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
203 
204 // ===================================================================
205 
206 class ObservableEvents_DataSourceInstanceStateChange::_Internal {
207  public:
208   using HasBits = decltype(std::declval<ObservableEvents_DataSourceInstanceStateChange>()._impl_._has_bits_);
set_has_producer_name(HasBits * has_bits)209   static void set_has_producer_name(HasBits* has_bits) {
210     (*has_bits)[0] |= 1u;
211   }
set_has_data_source_name(HasBits * has_bits)212   static void set_has_data_source_name(HasBits* has_bits) {
213     (*has_bits)[0] |= 2u;
214   }
set_has_state(HasBits * has_bits)215   static void set_has_state(HasBits* has_bits) {
216     (*has_bits)[0] |= 4u;
217   }
218 };
219 
ObservableEvents_DataSourceInstanceStateChange(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)220 ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(::PROTOBUF_NAMESPACE_ID::Arena* arena,
221                          bool is_message_owned)
222   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
223   SharedCtor(arena, is_message_owned);
224   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
225 }
ObservableEvents_DataSourceInstanceStateChange(const ObservableEvents_DataSourceInstanceStateChange & from)226 ObservableEvents_DataSourceInstanceStateChange::ObservableEvents_DataSourceInstanceStateChange(const ObservableEvents_DataSourceInstanceStateChange& from)
227   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
228   ObservableEvents_DataSourceInstanceStateChange* const _this = this; (void)_this;
229   new (&_impl_) Impl_{
230       decltype(_impl_._has_bits_){from._impl_._has_bits_}
231     , /*decltype(_impl_._cached_size_)*/{}
232     , decltype(_impl_.producer_name_){}
233     , decltype(_impl_.data_source_name_){}
234     , decltype(_impl_.state_){}};
235 
236   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
237   _impl_.producer_name_.InitDefault();
238   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
239     _impl_.producer_name_.Set("", GetArenaForAllocation());
240   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
241   if (from._internal_has_producer_name()) {
242     _this->_impl_.producer_name_.Set(from._internal_producer_name(),
243       _this->GetArenaForAllocation());
244   }
245   _impl_.data_source_name_.InitDefault();
246   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
247     _impl_.data_source_name_.Set("", GetArenaForAllocation());
248   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
249   if (from._internal_has_data_source_name()) {
250     _this->_impl_.data_source_name_.Set(from._internal_data_source_name(),
251       _this->GetArenaForAllocation());
252   }
253   _this->_impl_.state_ = from._impl_.state_;
254   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
255 }
256 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)257 inline void ObservableEvents_DataSourceInstanceStateChange::SharedCtor(
258     ::_pb::Arena* arena, bool is_message_owned) {
259   (void)arena;
260   (void)is_message_owned;
261   new (&_impl_) Impl_{
262       decltype(_impl_._has_bits_){}
263     , /*decltype(_impl_._cached_size_)*/{}
264     , decltype(_impl_.producer_name_){}
265     , decltype(_impl_.data_source_name_){}
266     , decltype(_impl_.state_){1}
267   };
268   _impl_.producer_name_.InitDefault();
269   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
270     _impl_.producer_name_.Set("", GetArenaForAllocation());
271   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
272   _impl_.data_source_name_.InitDefault();
273   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
274     _impl_.data_source_name_.Set("", GetArenaForAllocation());
275   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
276 }
277 
~ObservableEvents_DataSourceInstanceStateChange()278 ObservableEvents_DataSourceInstanceStateChange::~ObservableEvents_DataSourceInstanceStateChange() {
279   // @@protoc_insertion_point(destructor:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
280   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
281   (void)arena;
282     return;
283   }
284   SharedDtor();
285 }
286 
SharedDtor()287 inline void ObservableEvents_DataSourceInstanceStateChange::SharedDtor() {
288   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
289   _impl_.producer_name_.Destroy();
290   _impl_.data_source_name_.Destroy();
291 }
292 
SetCachedSize(int size) const293 void ObservableEvents_DataSourceInstanceStateChange::SetCachedSize(int size) const {
294   _impl_._cached_size_.Set(size);
295 }
296 
Clear()297 void ObservableEvents_DataSourceInstanceStateChange::Clear() {
298 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
299   ::uint32_t cached_has_bits = 0;
300   // Prevent compiler warnings about cached_has_bits being unused
301   (void) cached_has_bits;
302 
303   cached_has_bits = _impl_._has_bits_[0];
304   if (cached_has_bits & 0x00000007u) {
305     if (cached_has_bits & 0x00000001u) {
306       _impl_.producer_name_.ClearNonDefaultToEmpty();
307     }
308     if (cached_has_bits & 0x00000002u) {
309       _impl_.data_source_name_.ClearNonDefaultToEmpty();
310     }
311     _impl_.state_ = 1;
312   }
313   _impl_._has_bits_.Clear();
314   _internal_metadata_.Clear<std::string>();
315 }
316 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)317 const char* ObservableEvents_DataSourceInstanceStateChange::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
318 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
319   _Internal::HasBits has_bits{};
320   while (!ctx->Done(&ptr)) {
321     ::uint32_t tag;
322     ptr = ::_pbi::ReadTag(ptr, &tag);
323     switch (tag >> 3) {
324       // optional string producer_name = 1;
325       case 1:
326         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
327           auto str = _internal_mutable_producer_name();
328           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
329           CHK_(ptr);
330         } else {
331           goto handle_unusual;
332         }
333         continue;
334       // optional string data_source_name = 2;
335       case 2:
336         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
337           auto str = _internal_mutable_data_source_name();
338           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
339           CHK_(ptr);
340         } else {
341           goto handle_unusual;
342         }
343         continue;
344       // optional .perfetto.protos.ObservableEvents.DataSourceInstanceState state = 3;
345       case 3:
346         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
347           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
348           CHK_(ptr);
349           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::ObservableEvents_DataSourceInstanceState_IsValid(val))) {
350             _internal_set_state(static_cast<::perfetto::protos::ObservableEvents_DataSourceInstanceState>(val));
351           } else {
352             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
353           }
354         } else {
355           goto handle_unusual;
356         }
357         continue;
358       default:
359         goto handle_unusual;
360     }  // switch
361   handle_unusual:
362     if ((tag == 0) || ((tag & 7) == 4)) {
363       CHK_(ptr);
364       ctx->SetLastTag(tag);
365       goto message_done;
366     }
367     ptr = UnknownFieldParse(
368         tag,
369         _internal_metadata_.mutable_unknown_fields<std::string>(),
370         ptr, ctx);
371     CHK_(ptr != nullptr);
372   }  // while
373 message_done:
374   _impl_._has_bits_.Or(has_bits);
375   return ptr;
376 failure:
377   ptr = nullptr;
378   goto message_done;
379 #undef CHK_
380 }
381 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const382 ::uint8_t* ObservableEvents_DataSourceInstanceStateChange::_InternalSerialize(
383     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
384   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
385   ::uint32_t cached_has_bits = 0;
386   (void) cached_has_bits;
387 
388   cached_has_bits = _impl_._has_bits_[0];
389   // optional string producer_name = 1;
390   if (cached_has_bits & 0x00000001u) {
391     target = stream->WriteStringMaybeAliased(
392         1, this->_internal_producer_name(), target);
393   }
394 
395   // optional string data_source_name = 2;
396   if (cached_has_bits & 0x00000002u) {
397     target = stream->WriteStringMaybeAliased(
398         2, this->_internal_data_source_name(), target);
399   }
400 
401   // optional .perfetto.protos.ObservableEvents.DataSourceInstanceState state = 3;
402   if (cached_has_bits & 0x00000004u) {
403     target = stream->EnsureSpace(target);
404     target = ::_pbi::WireFormatLite::WriteEnumToArray(
405       3, this->_internal_state(), target);
406   }
407 
408   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
409     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
410         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
411   }
412   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
413   return target;
414 }
415 
ByteSizeLong() const416 size_t ObservableEvents_DataSourceInstanceStateChange::ByteSizeLong() const {
417 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
418   size_t total_size = 0;
419 
420   ::uint32_t cached_has_bits = 0;
421   // Prevent compiler warnings about cached_has_bits being unused
422   (void) cached_has_bits;
423 
424   cached_has_bits = _impl_._has_bits_[0];
425   if (cached_has_bits & 0x00000007u) {
426     // optional string producer_name = 1;
427     if (cached_has_bits & 0x00000001u) {
428       total_size += 1 +
429         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
430           this->_internal_producer_name());
431     }
432 
433     // optional string data_source_name = 2;
434     if (cached_has_bits & 0x00000002u) {
435       total_size += 1 +
436         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
437           this->_internal_data_source_name());
438     }
439 
440     // optional .perfetto.protos.ObservableEvents.DataSourceInstanceState state = 3;
441     if (cached_has_bits & 0x00000004u) {
442       total_size += 1 +
443         ::_pbi::WireFormatLite::EnumSize(this->_internal_state());
444     }
445 
446   }
447   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
448     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
449   }
450   int cached_size = ::_pbi::ToCachedSize(total_size);
451   SetCachedSize(cached_size);
452   return total_size;
453 }
454 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)455 void ObservableEvents_DataSourceInstanceStateChange::CheckTypeAndMergeFrom(
456     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
457   MergeFrom(*::_pbi::DownCast<const ObservableEvents_DataSourceInstanceStateChange*>(
458       &from));
459 }
460 
MergeFrom(const ObservableEvents_DataSourceInstanceStateChange & from)461 void ObservableEvents_DataSourceInstanceStateChange::MergeFrom(const ObservableEvents_DataSourceInstanceStateChange& from) {
462   ObservableEvents_DataSourceInstanceStateChange* const _this = this;
463   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
464   GOOGLE_DCHECK_NE(&from, _this);
465   ::uint32_t cached_has_bits = 0;
466   (void) cached_has_bits;
467 
468   cached_has_bits = from._impl_._has_bits_[0];
469   if (cached_has_bits & 0x00000007u) {
470     if (cached_has_bits & 0x00000001u) {
471       _this->_internal_set_producer_name(from._internal_producer_name());
472     }
473     if (cached_has_bits & 0x00000002u) {
474       _this->_internal_set_data_source_name(from._internal_data_source_name());
475     }
476     if (cached_has_bits & 0x00000004u) {
477       _this->_impl_.state_ = from._impl_.state_;
478     }
479     _this->_impl_._has_bits_[0] |= cached_has_bits;
480   }
481   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
482 }
483 
CopyFrom(const ObservableEvents_DataSourceInstanceStateChange & from)484 void ObservableEvents_DataSourceInstanceStateChange::CopyFrom(const ObservableEvents_DataSourceInstanceStateChange& from) {
485 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ObservableEvents.DataSourceInstanceStateChange)
486   if (&from == this) return;
487   Clear();
488   MergeFrom(from);
489 }
490 
IsInitialized() const491 bool ObservableEvents_DataSourceInstanceStateChange::IsInitialized() const {
492   return true;
493 }
494 
InternalSwap(ObservableEvents_DataSourceInstanceStateChange * other)495 void ObservableEvents_DataSourceInstanceStateChange::InternalSwap(ObservableEvents_DataSourceInstanceStateChange* other) {
496   using std::swap;
497   auto* lhs_arena = GetArenaForAllocation();
498   auto* rhs_arena = other->GetArenaForAllocation();
499   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
500   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
501   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
502       &_impl_.producer_name_, lhs_arena,
503       &other->_impl_.producer_name_, rhs_arena
504   );
505   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
506       &_impl_.data_source_name_, lhs_arena,
507       &other->_impl_.data_source_name_, rhs_arena
508   );
509   swap(_impl_.state_, other->_impl_.state_);
510 }
511 
GetTypeName() const512 std::string ObservableEvents_DataSourceInstanceStateChange::GetTypeName() const {
513   return "perfetto.protos.ObservableEvents.DataSourceInstanceStateChange";
514 }
515 
516 
517 // ===================================================================
518 
519 class ObservableEvents_CloneTriggerHit::_Internal {
520  public:
521   using HasBits = decltype(std::declval<ObservableEvents_CloneTriggerHit>()._impl_._has_bits_);
set_has_tracing_session_id(HasBits * has_bits)522   static void set_has_tracing_session_id(HasBits* has_bits) {
523     (*has_bits)[0] |= 4u;
524   }
set_has_trigger_name(HasBits * has_bits)525   static void set_has_trigger_name(HasBits* has_bits) {
526     (*has_bits)[0] |= 1u;
527   }
set_has_producer_name(HasBits * has_bits)528   static void set_has_producer_name(HasBits* has_bits) {
529     (*has_bits)[0] |= 2u;
530   }
set_has_producer_uid(HasBits * has_bits)531   static void set_has_producer_uid(HasBits* has_bits) {
532     (*has_bits)[0] |= 16u;
533   }
set_has_boot_time_ns(HasBits * has_bits)534   static void set_has_boot_time_ns(HasBits* has_bits) {
535     (*has_bits)[0] |= 8u;
536   }
537 };
538 
ObservableEvents_CloneTriggerHit(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)539 ObservableEvents_CloneTriggerHit::ObservableEvents_CloneTriggerHit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
540                          bool is_message_owned)
541   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
542   SharedCtor(arena, is_message_owned);
543   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ObservableEvents.CloneTriggerHit)
544 }
ObservableEvents_CloneTriggerHit(const ObservableEvents_CloneTriggerHit & from)545 ObservableEvents_CloneTriggerHit::ObservableEvents_CloneTriggerHit(const ObservableEvents_CloneTriggerHit& from)
546   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
547   ObservableEvents_CloneTriggerHit* const _this = this; (void)_this;
548   new (&_impl_) Impl_{
549       decltype(_impl_._has_bits_){from._impl_._has_bits_}
550     , /*decltype(_impl_._cached_size_)*/{}
551     , decltype(_impl_.trigger_name_){}
552     , decltype(_impl_.producer_name_){}
553     , decltype(_impl_.tracing_session_id_){}
554     , decltype(_impl_.boot_time_ns_){}
555     , decltype(_impl_.producer_uid_){}};
556 
557   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
558   _impl_.trigger_name_.InitDefault();
559   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
560     _impl_.trigger_name_.Set("", GetArenaForAllocation());
561   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
562   if (from._internal_has_trigger_name()) {
563     _this->_impl_.trigger_name_.Set(from._internal_trigger_name(),
564       _this->GetArenaForAllocation());
565   }
566   _impl_.producer_name_.InitDefault();
567   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
568     _impl_.producer_name_.Set("", GetArenaForAllocation());
569   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
570   if (from._internal_has_producer_name()) {
571     _this->_impl_.producer_name_.Set(from._internal_producer_name(),
572       _this->GetArenaForAllocation());
573   }
574   ::memcpy(&_impl_.tracing_session_id_, &from._impl_.tracing_session_id_,
575     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.producer_uid_) -
576     reinterpret_cast<char*>(&_impl_.tracing_session_id_)) + sizeof(_impl_.producer_uid_));
577   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ObservableEvents.CloneTriggerHit)
578 }
579 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)580 inline void ObservableEvents_CloneTriggerHit::SharedCtor(
581     ::_pb::Arena* arena, bool is_message_owned) {
582   (void)arena;
583   (void)is_message_owned;
584   new (&_impl_) Impl_{
585       decltype(_impl_._has_bits_){}
586     , /*decltype(_impl_._cached_size_)*/{}
587     , decltype(_impl_.trigger_name_){}
588     , decltype(_impl_.producer_name_){}
589     , decltype(_impl_.tracing_session_id_){::int64_t{0}}
590     , decltype(_impl_.boot_time_ns_){::uint64_t{0u}}
591     , decltype(_impl_.producer_uid_){0u}
592   };
593   _impl_.trigger_name_.InitDefault();
594   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
595     _impl_.trigger_name_.Set("", GetArenaForAllocation());
596   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
597   _impl_.producer_name_.InitDefault();
598   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
599     _impl_.producer_name_.Set("", GetArenaForAllocation());
600   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
601 }
602 
~ObservableEvents_CloneTriggerHit()603 ObservableEvents_CloneTriggerHit::~ObservableEvents_CloneTriggerHit() {
604   // @@protoc_insertion_point(destructor:perfetto.protos.ObservableEvents.CloneTriggerHit)
605   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
606   (void)arena;
607     return;
608   }
609   SharedDtor();
610 }
611 
SharedDtor()612 inline void ObservableEvents_CloneTriggerHit::SharedDtor() {
613   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
614   _impl_.trigger_name_.Destroy();
615   _impl_.producer_name_.Destroy();
616 }
617 
SetCachedSize(int size) const618 void ObservableEvents_CloneTriggerHit::SetCachedSize(int size) const {
619   _impl_._cached_size_.Set(size);
620 }
621 
Clear()622 void ObservableEvents_CloneTriggerHit::Clear() {
623 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ObservableEvents.CloneTriggerHit)
624   ::uint32_t cached_has_bits = 0;
625   // Prevent compiler warnings about cached_has_bits being unused
626   (void) cached_has_bits;
627 
628   cached_has_bits = _impl_._has_bits_[0];
629   if (cached_has_bits & 0x00000003u) {
630     if (cached_has_bits & 0x00000001u) {
631       _impl_.trigger_name_.ClearNonDefaultToEmpty();
632     }
633     if (cached_has_bits & 0x00000002u) {
634       _impl_.producer_name_.ClearNonDefaultToEmpty();
635     }
636   }
637   if (cached_has_bits & 0x0000001cu) {
638     ::memset(&_impl_.tracing_session_id_, 0, static_cast<size_t>(
639         reinterpret_cast<char*>(&_impl_.producer_uid_) -
640         reinterpret_cast<char*>(&_impl_.tracing_session_id_)) + sizeof(_impl_.producer_uid_));
641   }
642   _impl_._has_bits_.Clear();
643   _internal_metadata_.Clear<std::string>();
644 }
645 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)646 const char* ObservableEvents_CloneTriggerHit::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
647 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
648   _Internal::HasBits has_bits{};
649   while (!ctx->Done(&ptr)) {
650     ::uint32_t tag;
651     ptr = ::_pbi::ReadTag(ptr, &tag);
652     switch (tag >> 3) {
653       // optional int64 tracing_session_id = 1;
654       case 1:
655         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
656           _Internal::set_has_tracing_session_id(&has_bits);
657           _impl_.tracing_session_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
658           CHK_(ptr);
659         } else {
660           goto handle_unusual;
661         }
662         continue;
663       // optional string trigger_name = 2;
664       case 2:
665         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
666           auto str = _internal_mutable_trigger_name();
667           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
668           CHK_(ptr);
669         } else {
670           goto handle_unusual;
671         }
672         continue;
673       // optional string producer_name = 3;
674       case 3:
675         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
676           auto str = _internal_mutable_producer_name();
677           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
678           CHK_(ptr);
679         } else {
680           goto handle_unusual;
681         }
682         continue;
683       // optional uint32 producer_uid = 4;
684       case 4:
685         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
686           _Internal::set_has_producer_uid(&has_bits);
687           _impl_.producer_uid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
688           CHK_(ptr);
689         } else {
690           goto handle_unusual;
691         }
692         continue;
693       // optional uint64 boot_time_ns = 5;
694       case 5:
695         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
696           _Internal::set_has_boot_time_ns(&has_bits);
697           _impl_.boot_time_ns_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
698           CHK_(ptr);
699         } else {
700           goto handle_unusual;
701         }
702         continue;
703       default:
704         goto handle_unusual;
705     }  // switch
706   handle_unusual:
707     if ((tag == 0) || ((tag & 7) == 4)) {
708       CHK_(ptr);
709       ctx->SetLastTag(tag);
710       goto message_done;
711     }
712     ptr = UnknownFieldParse(
713         tag,
714         _internal_metadata_.mutable_unknown_fields<std::string>(),
715         ptr, ctx);
716     CHK_(ptr != nullptr);
717   }  // while
718 message_done:
719   _impl_._has_bits_.Or(has_bits);
720   return ptr;
721 failure:
722   ptr = nullptr;
723   goto message_done;
724 #undef CHK_
725 }
726 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const727 ::uint8_t* ObservableEvents_CloneTriggerHit::_InternalSerialize(
728     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
729   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ObservableEvents.CloneTriggerHit)
730   ::uint32_t cached_has_bits = 0;
731   (void) cached_has_bits;
732 
733   cached_has_bits = _impl_._has_bits_[0];
734   // optional int64 tracing_session_id = 1;
735   if (cached_has_bits & 0x00000004u) {
736     target = stream->EnsureSpace(target);
737     target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_tracing_session_id(), target);
738   }
739 
740   // optional string trigger_name = 2;
741   if (cached_has_bits & 0x00000001u) {
742     target = stream->WriteStringMaybeAliased(
743         2, this->_internal_trigger_name(), target);
744   }
745 
746   // optional string producer_name = 3;
747   if (cached_has_bits & 0x00000002u) {
748     target = stream->WriteStringMaybeAliased(
749         3, this->_internal_producer_name(), target);
750   }
751 
752   // optional uint32 producer_uid = 4;
753   if (cached_has_bits & 0x00000010u) {
754     target = stream->EnsureSpace(target);
755     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_producer_uid(), target);
756   }
757 
758   // optional uint64 boot_time_ns = 5;
759   if (cached_has_bits & 0x00000008u) {
760     target = stream->EnsureSpace(target);
761     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_boot_time_ns(), target);
762   }
763 
764   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
765     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
766         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
767   }
768   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ObservableEvents.CloneTriggerHit)
769   return target;
770 }
771 
ByteSizeLong() const772 size_t ObservableEvents_CloneTriggerHit::ByteSizeLong() const {
773 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ObservableEvents.CloneTriggerHit)
774   size_t total_size = 0;
775 
776   ::uint32_t cached_has_bits = 0;
777   // Prevent compiler warnings about cached_has_bits being unused
778   (void) cached_has_bits;
779 
780   cached_has_bits = _impl_._has_bits_[0];
781   if (cached_has_bits & 0x0000001fu) {
782     // optional string trigger_name = 2;
783     if (cached_has_bits & 0x00000001u) {
784       total_size += 1 +
785         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
786           this->_internal_trigger_name());
787     }
788 
789     // optional string producer_name = 3;
790     if (cached_has_bits & 0x00000002u) {
791       total_size += 1 +
792         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
793           this->_internal_producer_name());
794     }
795 
796     // optional int64 tracing_session_id = 1;
797     if (cached_has_bits & 0x00000004u) {
798       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_tracing_session_id());
799     }
800 
801     // optional uint64 boot_time_ns = 5;
802     if (cached_has_bits & 0x00000008u) {
803       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_boot_time_ns());
804     }
805 
806     // optional uint32 producer_uid = 4;
807     if (cached_has_bits & 0x00000010u) {
808       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_producer_uid());
809     }
810 
811   }
812   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
813     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
814   }
815   int cached_size = ::_pbi::ToCachedSize(total_size);
816   SetCachedSize(cached_size);
817   return total_size;
818 }
819 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)820 void ObservableEvents_CloneTriggerHit::CheckTypeAndMergeFrom(
821     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
822   MergeFrom(*::_pbi::DownCast<const ObservableEvents_CloneTriggerHit*>(
823       &from));
824 }
825 
MergeFrom(const ObservableEvents_CloneTriggerHit & from)826 void ObservableEvents_CloneTriggerHit::MergeFrom(const ObservableEvents_CloneTriggerHit& from) {
827   ObservableEvents_CloneTriggerHit* const _this = this;
828   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ObservableEvents.CloneTriggerHit)
829   GOOGLE_DCHECK_NE(&from, _this);
830   ::uint32_t cached_has_bits = 0;
831   (void) cached_has_bits;
832 
833   cached_has_bits = from._impl_._has_bits_[0];
834   if (cached_has_bits & 0x0000001fu) {
835     if (cached_has_bits & 0x00000001u) {
836       _this->_internal_set_trigger_name(from._internal_trigger_name());
837     }
838     if (cached_has_bits & 0x00000002u) {
839       _this->_internal_set_producer_name(from._internal_producer_name());
840     }
841     if (cached_has_bits & 0x00000004u) {
842       _this->_impl_.tracing_session_id_ = from._impl_.tracing_session_id_;
843     }
844     if (cached_has_bits & 0x00000008u) {
845       _this->_impl_.boot_time_ns_ = from._impl_.boot_time_ns_;
846     }
847     if (cached_has_bits & 0x00000010u) {
848       _this->_impl_.producer_uid_ = from._impl_.producer_uid_;
849     }
850     _this->_impl_._has_bits_[0] |= cached_has_bits;
851   }
852   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
853 }
854 
CopyFrom(const ObservableEvents_CloneTriggerHit & from)855 void ObservableEvents_CloneTriggerHit::CopyFrom(const ObservableEvents_CloneTriggerHit& from) {
856 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ObservableEvents.CloneTriggerHit)
857   if (&from == this) return;
858   Clear();
859   MergeFrom(from);
860 }
861 
IsInitialized() const862 bool ObservableEvents_CloneTriggerHit::IsInitialized() const {
863   return true;
864 }
865 
InternalSwap(ObservableEvents_CloneTriggerHit * other)866 void ObservableEvents_CloneTriggerHit::InternalSwap(ObservableEvents_CloneTriggerHit* other) {
867   using std::swap;
868   auto* lhs_arena = GetArenaForAllocation();
869   auto* rhs_arena = other->GetArenaForAllocation();
870   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
871   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
872   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
873       &_impl_.trigger_name_, lhs_arena,
874       &other->_impl_.trigger_name_, rhs_arena
875   );
876   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
877       &_impl_.producer_name_, lhs_arena,
878       &other->_impl_.producer_name_, rhs_arena
879   );
880   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
881       PROTOBUF_FIELD_OFFSET(ObservableEvents_CloneTriggerHit, _impl_.producer_uid_)
882       + sizeof(ObservableEvents_CloneTriggerHit::_impl_.producer_uid_)  // NOLINT
883       - PROTOBUF_FIELD_OFFSET(ObservableEvents_CloneTriggerHit, _impl_.tracing_session_id_)>(
884           reinterpret_cast<char*>(&_impl_.tracing_session_id_),
885           reinterpret_cast<char*>(&other->_impl_.tracing_session_id_));
886 }
887 
GetTypeName() const888 std::string ObservableEvents_CloneTriggerHit::GetTypeName() const {
889   return "perfetto.protos.ObservableEvents.CloneTriggerHit";
890 }
891 
892 
893 // ===================================================================
894 
895 class ObservableEvents::_Internal {
896  public:
897   using HasBits = decltype(std::declval<ObservableEvents>()._impl_._has_bits_);
set_has_all_data_sources_started(HasBits * has_bits)898   static void set_has_all_data_sources_started(HasBits* has_bits) {
899     (*has_bits)[0] |= 2u;
900   }
901   static const ::perfetto::protos::ObservableEvents_CloneTriggerHit& clone_trigger_hit(const ObservableEvents* msg);
set_has_clone_trigger_hit(HasBits * has_bits)902   static void set_has_clone_trigger_hit(HasBits* has_bits) {
903     (*has_bits)[0] |= 1u;
904   }
905 };
906 
907 const ::perfetto::protos::ObservableEvents_CloneTriggerHit&
clone_trigger_hit(const ObservableEvents * msg)908 ObservableEvents::_Internal::clone_trigger_hit(const ObservableEvents* msg) {
909   return *msg->_impl_.clone_trigger_hit_;
910 }
ObservableEvents(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)911 ObservableEvents::ObservableEvents(::PROTOBUF_NAMESPACE_ID::Arena* arena,
912                          bool is_message_owned)
913   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
914   SharedCtor(arena, is_message_owned);
915   // @@protoc_insertion_point(arena_constructor:perfetto.protos.ObservableEvents)
916 }
ObservableEvents(const ObservableEvents & from)917 ObservableEvents::ObservableEvents(const ObservableEvents& from)
918   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
919   ObservableEvents* const _this = this; (void)_this;
920   new (&_impl_) Impl_{
921       decltype(_impl_._has_bits_){from._impl_._has_bits_}
922     , /*decltype(_impl_._cached_size_)*/{}
923     , decltype(_impl_.instance_state_changes_){from._impl_.instance_state_changes_}
924     , decltype(_impl_.clone_trigger_hit_){nullptr}
925     , decltype(_impl_.all_data_sources_started_){}};
926 
927   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
928   if (from._internal_has_clone_trigger_hit()) {
929     _this->_impl_.clone_trigger_hit_ = new ::perfetto::protos::ObservableEvents_CloneTriggerHit(*from._impl_.clone_trigger_hit_);
930   }
931   _this->_impl_.all_data_sources_started_ = from._impl_.all_data_sources_started_;
932   // @@protoc_insertion_point(copy_constructor:perfetto.protos.ObservableEvents)
933 }
934 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)935 inline void ObservableEvents::SharedCtor(
936     ::_pb::Arena* arena, bool is_message_owned) {
937   (void)arena;
938   (void)is_message_owned;
939   new (&_impl_) Impl_{
940       decltype(_impl_._has_bits_){}
941     , /*decltype(_impl_._cached_size_)*/{}
942     , decltype(_impl_.instance_state_changes_){arena}
943     , decltype(_impl_.clone_trigger_hit_){nullptr}
944     , decltype(_impl_.all_data_sources_started_){false}
945   };
946 }
947 
~ObservableEvents()948 ObservableEvents::~ObservableEvents() {
949   // @@protoc_insertion_point(destructor:perfetto.protos.ObservableEvents)
950   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
951   (void)arena;
952     return;
953   }
954   SharedDtor();
955 }
956 
SharedDtor()957 inline void ObservableEvents::SharedDtor() {
958   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
959   _impl_.instance_state_changes_.~RepeatedPtrField();
960   if (this != internal_default_instance()) delete _impl_.clone_trigger_hit_;
961 }
962 
SetCachedSize(int size) const963 void ObservableEvents::SetCachedSize(int size) const {
964   _impl_._cached_size_.Set(size);
965 }
966 
Clear()967 void ObservableEvents::Clear() {
968 // @@protoc_insertion_point(message_clear_start:perfetto.protos.ObservableEvents)
969   ::uint32_t cached_has_bits = 0;
970   // Prevent compiler warnings about cached_has_bits being unused
971   (void) cached_has_bits;
972 
973   _impl_.instance_state_changes_.Clear();
974   cached_has_bits = _impl_._has_bits_[0];
975   if (cached_has_bits & 0x00000001u) {
976     GOOGLE_DCHECK(_impl_.clone_trigger_hit_ != nullptr);
977     _impl_.clone_trigger_hit_->Clear();
978   }
979   _impl_.all_data_sources_started_ = false;
980   _impl_._has_bits_.Clear();
981   _internal_metadata_.Clear<std::string>();
982 }
983 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)984 const char* ObservableEvents::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
985 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
986   _Internal::HasBits has_bits{};
987   while (!ctx->Done(&ptr)) {
988     ::uint32_t tag;
989     ptr = ::_pbi::ReadTag(ptr, &tag);
990     switch (tag >> 3) {
991       // repeated .perfetto.protos.ObservableEvents.DataSourceInstanceStateChange instance_state_changes = 1;
992       case 1:
993         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
994           ptr -= 1;
995           do {
996             ptr += 1;
997             ptr = ctx->ParseMessage(_internal_add_instance_state_changes(), ptr);
998             CHK_(ptr);
999             if (!ctx->DataAvailable(ptr)) break;
1000           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
1001         } else {
1002           goto handle_unusual;
1003         }
1004         continue;
1005       // optional bool all_data_sources_started = 2;
1006       case 2:
1007         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1008           _Internal::set_has_all_data_sources_started(&has_bits);
1009           _impl_.all_data_sources_started_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1010           CHK_(ptr);
1011         } else {
1012           goto handle_unusual;
1013         }
1014         continue;
1015       // optional .perfetto.protos.ObservableEvents.CloneTriggerHit clone_trigger_hit = 3;
1016       case 3:
1017         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1018           ptr = ctx->ParseMessage(_internal_mutable_clone_trigger_hit(), ptr);
1019           CHK_(ptr);
1020         } else {
1021           goto handle_unusual;
1022         }
1023         continue;
1024       default:
1025         goto handle_unusual;
1026     }  // switch
1027   handle_unusual:
1028     if ((tag == 0) || ((tag & 7) == 4)) {
1029       CHK_(ptr);
1030       ctx->SetLastTag(tag);
1031       goto message_done;
1032     }
1033     ptr = UnknownFieldParse(
1034         tag,
1035         _internal_metadata_.mutable_unknown_fields<std::string>(),
1036         ptr, ctx);
1037     CHK_(ptr != nullptr);
1038   }  // while
1039 message_done:
1040   _impl_._has_bits_.Or(has_bits);
1041   return ptr;
1042 failure:
1043   ptr = nullptr;
1044   goto message_done;
1045 #undef CHK_
1046 }
1047 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1048 ::uint8_t* ObservableEvents::_InternalSerialize(
1049     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1050   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.ObservableEvents)
1051   ::uint32_t cached_has_bits = 0;
1052   (void) cached_has_bits;
1053 
1054   // repeated .perfetto.protos.ObservableEvents.DataSourceInstanceStateChange instance_state_changes = 1;
1055   for (unsigned i = 0,
1056       n = static_cast<unsigned>(this->_internal_instance_state_changes_size()); i < n; i++) {
1057     const auto& repfield = this->_internal_instance_state_changes(i);
1058     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1059         InternalWriteMessage(1, repfield, repfield.GetCachedSize(), target, stream);
1060   }
1061 
1062   cached_has_bits = _impl_._has_bits_[0];
1063   // optional bool all_data_sources_started = 2;
1064   if (cached_has_bits & 0x00000002u) {
1065     target = stream->EnsureSpace(target);
1066     target = ::_pbi::WireFormatLite::WriteBoolToArray(2, this->_internal_all_data_sources_started(), target);
1067   }
1068 
1069   // optional .perfetto.protos.ObservableEvents.CloneTriggerHit clone_trigger_hit = 3;
1070   if (cached_has_bits & 0x00000001u) {
1071     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1072       InternalWriteMessage(3, _Internal::clone_trigger_hit(this),
1073         _Internal::clone_trigger_hit(this).GetCachedSize(), target, stream);
1074   }
1075 
1076   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1077     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1078         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1079   }
1080   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.ObservableEvents)
1081   return target;
1082 }
1083 
ByteSizeLong() const1084 size_t ObservableEvents::ByteSizeLong() const {
1085 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.ObservableEvents)
1086   size_t total_size = 0;
1087 
1088   ::uint32_t cached_has_bits = 0;
1089   // Prevent compiler warnings about cached_has_bits being unused
1090   (void) cached_has_bits;
1091 
1092   // repeated .perfetto.protos.ObservableEvents.DataSourceInstanceStateChange instance_state_changes = 1;
1093   total_size += 1UL * this->_internal_instance_state_changes_size();
1094   for (const auto& msg : this->_impl_.instance_state_changes_) {
1095     total_size +=
1096       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
1097   }
1098 
1099   cached_has_bits = _impl_._has_bits_[0];
1100   if (cached_has_bits & 0x00000003u) {
1101     // optional .perfetto.protos.ObservableEvents.CloneTriggerHit clone_trigger_hit = 3;
1102     if (cached_has_bits & 0x00000001u) {
1103       total_size += 1 +
1104         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1105           *_impl_.clone_trigger_hit_);
1106     }
1107 
1108     // optional bool all_data_sources_started = 2;
1109     if (cached_has_bits & 0x00000002u) {
1110       total_size += 1 + 1;
1111     }
1112 
1113   }
1114   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1115     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1116   }
1117   int cached_size = ::_pbi::ToCachedSize(total_size);
1118   SetCachedSize(cached_size);
1119   return total_size;
1120 }
1121 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1122 void ObservableEvents::CheckTypeAndMergeFrom(
1123     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1124   MergeFrom(*::_pbi::DownCast<const ObservableEvents*>(
1125       &from));
1126 }
1127 
MergeFrom(const ObservableEvents & from)1128 void ObservableEvents::MergeFrom(const ObservableEvents& from) {
1129   ObservableEvents* const _this = this;
1130   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.ObservableEvents)
1131   GOOGLE_DCHECK_NE(&from, _this);
1132   ::uint32_t cached_has_bits = 0;
1133   (void) cached_has_bits;
1134 
1135   _this->_impl_.instance_state_changes_.MergeFrom(from._impl_.instance_state_changes_);
1136   cached_has_bits = from._impl_._has_bits_[0];
1137   if (cached_has_bits & 0x00000003u) {
1138     if (cached_has_bits & 0x00000001u) {
1139       _this->_internal_mutable_clone_trigger_hit()->::perfetto::protos::ObservableEvents_CloneTriggerHit::MergeFrom(
1140           from._internal_clone_trigger_hit());
1141     }
1142     if (cached_has_bits & 0x00000002u) {
1143       _this->_impl_.all_data_sources_started_ = from._impl_.all_data_sources_started_;
1144     }
1145     _this->_impl_._has_bits_[0] |= cached_has_bits;
1146   }
1147   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1148 }
1149 
CopyFrom(const ObservableEvents & from)1150 void ObservableEvents::CopyFrom(const ObservableEvents& from) {
1151 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.ObservableEvents)
1152   if (&from == this) return;
1153   Clear();
1154   MergeFrom(from);
1155 }
1156 
IsInitialized() const1157 bool ObservableEvents::IsInitialized() const {
1158   return true;
1159 }
1160 
InternalSwap(ObservableEvents * other)1161 void ObservableEvents::InternalSwap(ObservableEvents* other) {
1162   using std::swap;
1163   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1164   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1165   _impl_.instance_state_changes_.InternalSwap(&other->_impl_.instance_state_changes_);
1166   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1167       PROTOBUF_FIELD_OFFSET(ObservableEvents, _impl_.all_data_sources_started_)
1168       + sizeof(ObservableEvents::_impl_.all_data_sources_started_)  // NOLINT
1169       - PROTOBUF_FIELD_OFFSET(ObservableEvents, _impl_.clone_trigger_hit_)>(
1170           reinterpret_cast<char*>(&_impl_.clone_trigger_hit_),
1171           reinterpret_cast<char*>(&other->_impl_.clone_trigger_hit_));
1172 }
1173 
GetTypeName() const1174 std::string ObservableEvents::GetTypeName() const {
1175   return "perfetto.protos.ObservableEvents";
1176 }
1177 
1178 
1179 // @@protoc_insertion_point(namespace_scope)
1180 }  // namespace protos
1181 }  // namespace perfetto
1182 PROTOBUF_NAMESPACE_OPEN
1183 template<> PROTOBUF_NOINLINE ::perfetto::protos::ObservableEvents_DataSourceInstanceStateChange*
CreateMaybeMessage(Arena * arena)1184 Arena::CreateMaybeMessage< ::perfetto::protos::ObservableEvents_DataSourceInstanceStateChange >(Arena* arena) {
1185   return Arena::CreateMessageInternal< ::perfetto::protos::ObservableEvents_DataSourceInstanceStateChange >(arena);
1186 }
1187 template<> PROTOBUF_NOINLINE ::perfetto::protos::ObservableEvents_CloneTriggerHit*
CreateMaybeMessage(Arena * arena)1188 Arena::CreateMaybeMessage< ::perfetto::protos::ObservableEvents_CloneTriggerHit >(Arena* arena) {
1189   return Arena::CreateMessageInternal< ::perfetto::protos::ObservableEvents_CloneTriggerHit >(arena);
1190 }
1191 template<> PROTOBUF_NOINLINE ::perfetto::protos::ObservableEvents*
CreateMaybeMessage(Arena * arena)1192 Arena::CreateMaybeMessage< ::perfetto::protos::ObservableEvents >(Arena* arena) {
1193   return Arena::CreateMessageInternal< ::perfetto::protos::ObservableEvents >(arena);
1194 }
1195 PROTOBUF_NAMESPACE_CLOSE
1196 
1197 // @@protoc_insertion_point(global_scope)
1198 #include <google/protobuf/port_undef.inc>
1199