1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/common/perf_events.proto
3 
4 #include "protos/perfetto/common/perf_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 {
PerfEvents_Timebase(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR PerfEvents_Timebase::PerfEvents_Timebase(
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_.timestamp_clock_)*/0
29   , /*decltype(_impl_.interval_)*/{}
30   , /*decltype(_impl_.event_)*/{}
31   , /*decltype(_impl_._oneof_case_)*/{}} {}
32 struct PerfEvents_TimebaseDefaultTypeInternal {
PerfEvents_TimebaseDefaultTypeInternalperfetto::protos::PerfEvents_TimebaseDefaultTypeInternal33   PROTOBUF_CONSTEXPR PerfEvents_TimebaseDefaultTypeInternal()
34       : _instance(::_pbi::ConstantInitialized{}) {}
~PerfEvents_TimebaseDefaultTypeInternalperfetto::protos::PerfEvents_TimebaseDefaultTypeInternal35   ~PerfEvents_TimebaseDefaultTypeInternal() {}
36   union {  // NOLINT(misc-non-private-member-variables-in-classes)
37     PerfEvents_Timebase _instance;
38   };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PerfEvents_TimebaseDefaultTypeInternal _PerfEvents_Timebase_default_instance_;
PerfEvents_Tracepoint(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR PerfEvents_Tracepoint::PerfEvents_Tracepoint(
42     ::_pbi::ConstantInitialized): _impl_{
43     /*decltype(_impl_._has_bits_)*/{}
44   , /*decltype(_impl_._cached_size_)*/{}
45   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
46   , /*decltype(_impl_.filter_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}} {}
47 struct PerfEvents_TracepointDefaultTypeInternal {
PerfEvents_TracepointDefaultTypeInternalperfetto::protos::PerfEvents_TracepointDefaultTypeInternal48   PROTOBUF_CONSTEXPR PerfEvents_TracepointDefaultTypeInternal()
49       : _instance(::_pbi::ConstantInitialized{}) {}
~PerfEvents_TracepointDefaultTypeInternalperfetto::protos::PerfEvents_TracepointDefaultTypeInternal50   ~PerfEvents_TracepointDefaultTypeInternal() {}
51   union {  // NOLINT(misc-non-private-member-variables-in-classes)
52     PerfEvents_Tracepoint _instance;
53   };
54 };
55 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PerfEvents_TracepointDefaultTypeInternal _PerfEvents_Tracepoint_default_instance_;
PerfEvents_RawEvent(::_pbi::ConstantInitialized)56 PROTOBUF_CONSTEXPR PerfEvents_RawEvent::PerfEvents_RawEvent(
57     ::_pbi::ConstantInitialized): _impl_{
58     /*decltype(_impl_._has_bits_)*/{}
59   , /*decltype(_impl_._cached_size_)*/{}
60   , /*decltype(_impl_.config_)*/::uint64_t{0u}
61   , /*decltype(_impl_.config1_)*/::uint64_t{0u}
62   , /*decltype(_impl_.config2_)*/::uint64_t{0u}
63   , /*decltype(_impl_.type_)*/0u} {}
64 struct PerfEvents_RawEventDefaultTypeInternal {
PerfEvents_RawEventDefaultTypeInternalperfetto::protos::PerfEvents_RawEventDefaultTypeInternal65   PROTOBUF_CONSTEXPR PerfEvents_RawEventDefaultTypeInternal()
66       : _instance(::_pbi::ConstantInitialized{}) {}
~PerfEvents_RawEventDefaultTypeInternalperfetto::protos::PerfEvents_RawEventDefaultTypeInternal67   ~PerfEvents_RawEventDefaultTypeInternal() {}
68   union {  // NOLINT(misc-non-private-member-variables-in-classes)
69     PerfEvents_RawEvent _instance;
70   };
71 };
72 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PerfEvents_RawEventDefaultTypeInternal _PerfEvents_RawEvent_default_instance_;
PerfEvents(::_pbi::ConstantInitialized)73 PROTOBUF_CONSTEXPR PerfEvents::PerfEvents(
74     ::_pbi::ConstantInitialized): _impl_{
75     /*decltype(_impl_._cached_size_)*/{}} {}
76 struct PerfEventsDefaultTypeInternal {
PerfEventsDefaultTypeInternalperfetto::protos::PerfEventsDefaultTypeInternal77   PROTOBUF_CONSTEXPR PerfEventsDefaultTypeInternal()
78       : _instance(::_pbi::ConstantInitialized{}) {}
~PerfEventsDefaultTypeInternalperfetto::protos::PerfEventsDefaultTypeInternal79   ~PerfEventsDefaultTypeInternal() {}
80   union {  // NOLINT(misc-non-private-member-variables-in-classes)
81     PerfEvents _instance;
82   };
83 };
84 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PerfEventsDefaultTypeInternal _PerfEvents_default_instance_;
FollowerEvent(::_pbi::ConstantInitialized)85 PROTOBUF_CONSTEXPR FollowerEvent::FollowerEvent(
86     ::_pbi::ConstantInitialized): _impl_{
87     /*decltype(_impl_._has_bits_)*/{}
88   , /*decltype(_impl_._cached_size_)*/{}
89   , /*decltype(_impl_.name_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
90   , /*decltype(_impl_.event_)*/{}
91   , /*decltype(_impl_._oneof_case_)*/{}} {}
92 struct FollowerEventDefaultTypeInternal {
FollowerEventDefaultTypeInternalperfetto::protos::FollowerEventDefaultTypeInternal93   PROTOBUF_CONSTEXPR FollowerEventDefaultTypeInternal()
94       : _instance(::_pbi::ConstantInitialized{}) {}
~FollowerEventDefaultTypeInternalperfetto::protos::FollowerEventDefaultTypeInternal95   ~FollowerEventDefaultTypeInternal() {}
96   union {  // NOLINT(misc-non-private-member-variables-in-classes)
97     FollowerEvent _instance;
98   };
99 };
100 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FollowerEventDefaultTypeInternal _FollowerEvent_default_instance_;
101 }  // namespace protos
102 }  // namespace perfetto
103 namespace perfetto {
104 namespace protos {
PerfEvents_Counter_IsValid(int value)105 bool PerfEvents_Counter_IsValid(int value) {
106   switch (value) {
107     case 0:
108     case 1:
109     case 2:
110     case 3:
111     case 4:
112     case 5:
113     case 6:
114     case 7:
115     case 8:
116     case 9:
117     case 10:
118     case 11:
119     case 12:
120     case 13:
121     case 14:
122     case 15:
123     case 16:
124     case 17:
125     case 18:
126     case 19:
127     case 20:
128       return true;
129     default:
130       return false;
131   }
132 }
133 
134 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PerfEvents_Counter_strings[21] = {};
135 
136 static const char PerfEvents_Counter_names[] =
137   "HW_BRANCH_INSTRUCTIONS"
138   "HW_BRANCH_MISSES"
139   "HW_BUS_CYCLES"
140   "HW_CACHE_MISSES"
141   "HW_CACHE_REFERENCES"
142   "HW_CPU_CYCLES"
143   "HW_INSTRUCTIONS"
144   "HW_REF_CPU_CYCLES"
145   "HW_STALLED_CYCLES_BACKEND"
146   "HW_STALLED_CYCLES_FRONTEND"
147   "SW_ALIGNMENT_FAULTS"
148   "SW_CONTEXT_SWITCHES"
149   "SW_CPU_CLOCK"
150   "SW_CPU_MIGRATIONS"
151   "SW_DUMMY"
152   "SW_EMULATION_FAULTS"
153   "SW_PAGE_FAULTS"
154   "SW_PAGE_FAULTS_MAJ"
155   "SW_PAGE_FAULTS_MIN"
156   "SW_TASK_CLOCK"
157   "UNKNOWN_COUNTER";
158 
159 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PerfEvents_Counter_entries[] = {
160   { {PerfEvents_Counter_names + 0, 22}, 14 },
161   { {PerfEvents_Counter_names + 22, 16}, 15 },
162   { {PerfEvents_Counter_names + 38, 13}, 16 },
163   { {PerfEvents_Counter_names + 51, 15}, 13 },
164   { {PerfEvents_Counter_names + 66, 19}, 12 },
165   { {PerfEvents_Counter_names + 85, 13}, 10 },
166   { {PerfEvents_Counter_names + 98, 15}, 11 },
167   { {PerfEvents_Counter_names + 113, 17}, 19 },
168   { {PerfEvents_Counter_names + 130, 25}, 18 },
169   { {PerfEvents_Counter_names + 155, 26}, 17 },
170   { {PerfEvents_Counter_names + 181, 19}, 8 },
171   { {PerfEvents_Counter_names + 200, 19}, 4 },
172   { {PerfEvents_Counter_names + 219, 12}, 1 },
173   { {PerfEvents_Counter_names + 231, 17}, 5 },
174   { {PerfEvents_Counter_names + 248, 8}, 20 },
175   { {PerfEvents_Counter_names + 256, 19}, 9 },
176   { {PerfEvents_Counter_names + 275, 14}, 2 },
177   { {PerfEvents_Counter_names + 289, 18}, 7 },
178   { {PerfEvents_Counter_names + 307, 18}, 6 },
179   { {PerfEvents_Counter_names + 325, 13}, 3 },
180   { {PerfEvents_Counter_names + 338, 15}, 0 },
181 };
182 
183 static const int PerfEvents_Counter_entries_by_number[] = {
184   20, // 0 -> UNKNOWN_COUNTER
185   12, // 1 -> SW_CPU_CLOCK
186   16, // 2 -> SW_PAGE_FAULTS
187   19, // 3 -> SW_TASK_CLOCK
188   11, // 4 -> SW_CONTEXT_SWITCHES
189   13, // 5 -> SW_CPU_MIGRATIONS
190   18, // 6 -> SW_PAGE_FAULTS_MIN
191   17, // 7 -> SW_PAGE_FAULTS_MAJ
192   10, // 8 -> SW_ALIGNMENT_FAULTS
193   15, // 9 -> SW_EMULATION_FAULTS
194   5, // 10 -> HW_CPU_CYCLES
195   6, // 11 -> HW_INSTRUCTIONS
196   4, // 12 -> HW_CACHE_REFERENCES
197   3, // 13 -> HW_CACHE_MISSES
198   0, // 14 -> HW_BRANCH_INSTRUCTIONS
199   1, // 15 -> HW_BRANCH_MISSES
200   2, // 16 -> HW_BUS_CYCLES
201   9, // 17 -> HW_STALLED_CYCLES_FRONTEND
202   8, // 18 -> HW_STALLED_CYCLES_BACKEND
203   7, // 19 -> HW_REF_CPU_CYCLES
204   14, // 20 -> SW_DUMMY
205 };
206 
PerfEvents_Counter_Name(PerfEvents_Counter value)207 const std::string& PerfEvents_Counter_Name(
208     PerfEvents_Counter value) {
209   static const bool dummy =
210       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
211           PerfEvents_Counter_entries,
212           PerfEvents_Counter_entries_by_number,
213           21, PerfEvents_Counter_strings);
214   (void) dummy;
215   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
216       PerfEvents_Counter_entries,
217       PerfEvents_Counter_entries_by_number,
218       21, value);
219   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
220                      PerfEvents_Counter_strings[idx].get();
221 }
PerfEvents_Counter_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PerfEvents_Counter * value)222 bool PerfEvents_Counter_Parse(
223     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PerfEvents_Counter* value) {
224   int int_value;
225   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
226       PerfEvents_Counter_entries, 21, name, &int_value);
227   if (success) {
228     *value = static_cast<PerfEvents_Counter>(int_value);
229   }
230   return success;
231 }
232 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
233 constexpr PerfEvents_Counter PerfEvents::UNKNOWN_COUNTER;
234 constexpr PerfEvents_Counter PerfEvents::SW_CPU_CLOCK;
235 constexpr PerfEvents_Counter PerfEvents::SW_PAGE_FAULTS;
236 constexpr PerfEvents_Counter PerfEvents::SW_TASK_CLOCK;
237 constexpr PerfEvents_Counter PerfEvents::SW_CONTEXT_SWITCHES;
238 constexpr PerfEvents_Counter PerfEvents::SW_CPU_MIGRATIONS;
239 constexpr PerfEvents_Counter PerfEvents::SW_PAGE_FAULTS_MIN;
240 constexpr PerfEvents_Counter PerfEvents::SW_PAGE_FAULTS_MAJ;
241 constexpr PerfEvents_Counter PerfEvents::SW_ALIGNMENT_FAULTS;
242 constexpr PerfEvents_Counter PerfEvents::SW_EMULATION_FAULTS;
243 constexpr PerfEvents_Counter PerfEvents::SW_DUMMY;
244 constexpr PerfEvents_Counter PerfEvents::HW_CPU_CYCLES;
245 constexpr PerfEvents_Counter PerfEvents::HW_INSTRUCTIONS;
246 constexpr PerfEvents_Counter PerfEvents::HW_CACHE_REFERENCES;
247 constexpr PerfEvents_Counter PerfEvents::HW_CACHE_MISSES;
248 constexpr PerfEvents_Counter PerfEvents::HW_BRANCH_INSTRUCTIONS;
249 constexpr PerfEvents_Counter PerfEvents::HW_BRANCH_MISSES;
250 constexpr PerfEvents_Counter PerfEvents::HW_BUS_CYCLES;
251 constexpr PerfEvents_Counter PerfEvents::HW_STALLED_CYCLES_FRONTEND;
252 constexpr PerfEvents_Counter PerfEvents::HW_STALLED_CYCLES_BACKEND;
253 constexpr PerfEvents_Counter PerfEvents::HW_REF_CPU_CYCLES;
254 constexpr PerfEvents_Counter PerfEvents::Counter_MIN;
255 constexpr PerfEvents_Counter PerfEvents::Counter_MAX;
256 constexpr int PerfEvents::Counter_ARRAYSIZE;
257 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
PerfEvents_PerfClock_IsValid(int value)258 bool PerfEvents_PerfClock_IsValid(int value) {
259   switch (value) {
260     case 0:
261     case 1:
262     case 2:
263     case 3:
264     case 4:
265       return true;
266     default:
267       return false;
268   }
269 }
270 
271 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> PerfEvents_PerfClock_strings[5] = {};
272 
273 static const char PerfEvents_PerfClock_names[] =
274   "PERF_CLOCK_BOOTTIME"
275   "PERF_CLOCK_MONOTONIC"
276   "PERF_CLOCK_MONOTONIC_RAW"
277   "PERF_CLOCK_REALTIME"
278   "UNKNOWN_PERF_CLOCK";
279 
280 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry PerfEvents_PerfClock_entries[] = {
281   { {PerfEvents_PerfClock_names + 0, 19}, 4 },
282   { {PerfEvents_PerfClock_names + 19, 20}, 2 },
283   { {PerfEvents_PerfClock_names + 39, 24}, 3 },
284   { {PerfEvents_PerfClock_names + 63, 19}, 1 },
285   { {PerfEvents_PerfClock_names + 82, 18}, 0 },
286 };
287 
288 static const int PerfEvents_PerfClock_entries_by_number[] = {
289   4, // 0 -> UNKNOWN_PERF_CLOCK
290   3, // 1 -> PERF_CLOCK_REALTIME
291   1, // 2 -> PERF_CLOCK_MONOTONIC
292   2, // 3 -> PERF_CLOCK_MONOTONIC_RAW
293   0, // 4 -> PERF_CLOCK_BOOTTIME
294 };
295 
PerfEvents_PerfClock_Name(PerfEvents_PerfClock value)296 const std::string& PerfEvents_PerfClock_Name(
297     PerfEvents_PerfClock value) {
298   static const bool dummy =
299       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
300           PerfEvents_PerfClock_entries,
301           PerfEvents_PerfClock_entries_by_number,
302           5, PerfEvents_PerfClock_strings);
303   (void) dummy;
304   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
305       PerfEvents_PerfClock_entries,
306       PerfEvents_PerfClock_entries_by_number,
307       5, value);
308   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
309                      PerfEvents_PerfClock_strings[idx].get();
310 }
PerfEvents_PerfClock_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,PerfEvents_PerfClock * value)311 bool PerfEvents_PerfClock_Parse(
312     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PerfEvents_PerfClock* value) {
313   int int_value;
314   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
315       PerfEvents_PerfClock_entries, 5, name, &int_value);
316   if (success) {
317     *value = static_cast<PerfEvents_PerfClock>(int_value);
318   }
319   return success;
320 }
321 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
322 constexpr PerfEvents_PerfClock PerfEvents::UNKNOWN_PERF_CLOCK;
323 constexpr PerfEvents_PerfClock PerfEvents::PERF_CLOCK_REALTIME;
324 constexpr PerfEvents_PerfClock PerfEvents::PERF_CLOCK_MONOTONIC;
325 constexpr PerfEvents_PerfClock PerfEvents::PERF_CLOCK_MONOTONIC_RAW;
326 constexpr PerfEvents_PerfClock PerfEvents::PERF_CLOCK_BOOTTIME;
327 constexpr PerfEvents_PerfClock PerfEvents::PerfClock_MIN;
328 constexpr PerfEvents_PerfClock PerfEvents::PerfClock_MAX;
329 constexpr int PerfEvents::PerfClock_ARRAYSIZE;
330 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
331 
332 // ===================================================================
333 
334 class PerfEvents_Timebase::_Internal {
335  public:
336   using HasBits = decltype(std::declval<PerfEvents_Timebase>()._impl_._has_bits_);
337   static const ::perfetto::protos::PerfEvents_Tracepoint& tracepoint(const PerfEvents_Timebase* msg);
338   static const ::perfetto::protos::PerfEvents_RawEvent& raw_event(const PerfEvents_Timebase* msg);
set_has_timestamp_clock(HasBits * has_bits)339   static void set_has_timestamp_clock(HasBits* has_bits) {
340     (*has_bits)[0] |= 2u;
341   }
set_has_name(HasBits * has_bits)342   static void set_has_name(HasBits* has_bits) {
343     (*has_bits)[0] |= 1u;
344   }
345 };
346 
347 const ::perfetto::protos::PerfEvents_Tracepoint&
tracepoint(const PerfEvents_Timebase * msg)348 PerfEvents_Timebase::_Internal::tracepoint(const PerfEvents_Timebase* msg) {
349   return *msg->_impl_.event_.tracepoint_;
350 }
351 const ::perfetto::protos::PerfEvents_RawEvent&
raw_event(const PerfEvents_Timebase * msg)352 PerfEvents_Timebase::_Internal::raw_event(const PerfEvents_Timebase* msg) {
353   return *msg->_impl_.event_.raw_event_;
354 }
set_allocated_tracepoint(::perfetto::protos::PerfEvents_Tracepoint * tracepoint)355 void PerfEvents_Timebase::set_allocated_tracepoint(::perfetto::protos::PerfEvents_Tracepoint* tracepoint) {
356   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
357   clear_event();
358   if (tracepoint) {
359     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
360       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tracepoint);
361     if (message_arena != submessage_arena) {
362       tracepoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
363           message_arena, tracepoint, submessage_arena);
364     }
365     set_has_tracepoint();
366     _impl_.event_.tracepoint_ = tracepoint;
367   }
368   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.PerfEvents.Timebase.tracepoint)
369 }
set_allocated_raw_event(::perfetto::protos::PerfEvents_RawEvent * raw_event)370 void PerfEvents_Timebase::set_allocated_raw_event(::perfetto::protos::PerfEvents_RawEvent* raw_event) {
371   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
372   clear_event();
373   if (raw_event) {
374     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
375       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_event);
376     if (message_arena != submessage_arena) {
377       raw_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
378           message_arena, raw_event, submessage_arena);
379     }
380     set_has_raw_event();
381     _impl_.event_.raw_event_ = raw_event;
382   }
383   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.PerfEvents.Timebase.raw_event)
384 }
PerfEvents_Timebase(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)385 PerfEvents_Timebase::PerfEvents_Timebase(::PROTOBUF_NAMESPACE_ID::Arena* arena,
386                          bool is_message_owned)
387   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
388   SharedCtor(arena, is_message_owned);
389   // @@protoc_insertion_point(arena_constructor:perfetto.protos.PerfEvents.Timebase)
390 }
PerfEvents_Timebase(const PerfEvents_Timebase & from)391 PerfEvents_Timebase::PerfEvents_Timebase(const PerfEvents_Timebase& from)
392   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
393   PerfEvents_Timebase* const _this = this; (void)_this;
394   new (&_impl_) Impl_{
395       decltype(_impl_._has_bits_){from._impl_._has_bits_}
396     , /*decltype(_impl_._cached_size_)*/{}
397     , decltype(_impl_.name_){}
398     , decltype(_impl_.timestamp_clock_){}
399     , decltype(_impl_.interval_){}
400     , decltype(_impl_.event_){}
401     , /*decltype(_impl_._oneof_case_)*/{}};
402 
403   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
404   _impl_.name_.InitDefault();
405   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
406     _impl_.name_.Set("", GetArenaForAllocation());
407   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
408   if (from._internal_has_name()) {
409     _this->_impl_.name_.Set(from._internal_name(),
410       _this->GetArenaForAllocation());
411   }
412   _this->_impl_.timestamp_clock_ = from._impl_.timestamp_clock_;
413   clear_has_interval();
414   switch (from.interval_case()) {
415     case kFrequency: {
416       _this->_internal_set_frequency(from._internal_frequency());
417       break;
418     }
419     case kPeriod: {
420       _this->_internal_set_period(from._internal_period());
421       break;
422     }
423     case INTERVAL_NOT_SET: {
424       break;
425     }
426   }
427   clear_has_event();
428   switch (from.event_case()) {
429     case kCounter: {
430       _this->_internal_set_counter(from._internal_counter());
431       break;
432     }
433     case kTracepoint: {
434       _this->_internal_mutable_tracepoint()->::perfetto::protos::PerfEvents_Tracepoint::MergeFrom(
435           from._internal_tracepoint());
436       break;
437     }
438     case kRawEvent: {
439       _this->_internal_mutable_raw_event()->::perfetto::protos::PerfEvents_RawEvent::MergeFrom(
440           from._internal_raw_event());
441       break;
442     }
443     case EVENT_NOT_SET: {
444       break;
445     }
446   }
447   // @@protoc_insertion_point(copy_constructor:perfetto.protos.PerfEvents.Timebase)
448 }
449 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)450 inline void PerfEvents_Timebase::SharedCtor(
451     ::_pb::Arena* arena, bool is_message_owned) {
452   (void)arena;
453   (void)is_message_owned;
454   new (&_impl_) Impl_{
455       decltype(_impl_._has_bits_){}
456     , /*decltype(_impl_._cached_size_)*/{}
457     , decltype(_impl_.name_){}
458     , decltype(_impl_.timestamp_clock_){0}
459     , decltype(_impl_.interval_){}
460     , decltype(_impl_.event_){}
461     , /*decltype(_impl_._oneof_case_)*/{}
462   };
463   _impl_.name_.InitDefault();
464   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
465     _impl_.name_.Set("", GetArenaForAllocation());
466   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
467   clear_has_interval();
468   clear_has_event();
469 }
470 
~PerfEvents_Timebase()471 PerfEvents_Timebase::~PerfEvents_Timebase() {
472   // @@protoc_insertion_point(destructor:perfetto.protos.PerfEvents.Timebase)
473   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
474   (void)arena;
475     return;
476   }
477   SharedDtor();
478 }
479 
SharedDtor()480 inline void PerfEvents_Timebase::SharedDtor() {
481   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
482   _impl_.name_.Destroy();
483   if (has_interval()) {
484     clear_interval();
485   }
486   if (has_event()) {
487     clear_event();
488   }
489 }
490 
SetCachedSize(int size) const491 void PerfEvents_Timebase::SetCachedSize(int size) const {
492   _impl_._cached_size_.Set(size);
493 }
494 
clear_interval()495 void PerfEvents_Timebase::clear_interval() {
496 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.PerfEvents.Timebase)
497   switch (interval_case()) {
498     case kFrequency: {
499       // No need to clear
500       break;
501     }
502     case kPeriod: {
503       // No need to clear
504       break;
505     }
506     case INTERVAL_NOT_SET: {
507       break;
508     }
509   }
510   _impl_._oneof_case_[0] = INTERVAL_NOT_SET;
511 }
512 
clear_event()513 void PerfEvents_Timebase::clear_event() {
514 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.PerfEvents.Timebase)
515   switch (event_case()) {
516     case kCounter: {
517       // No need to clear
518       break;
519     }
520     case kTracepoint: {
521       if (GetArenaForAllocation() == nullptr) {
522         delete _impl_.event_.tracepoint_;
523       }
524       break;
525     }
526     case kRawEvent: {
527       if (GetArenaForAllocation() == nullptr) {
528         delete _impl_.event_.raw_event_;
529       }
530       break;
531     }
532     case EVENT_NOT_SET: {
533       break;
534     }
535   }
536   _impl_._oneof_case_[1] = EVENT_NOT_SET;
537 }
538 
539 
Clear()540 void PerfEvents_Timebase::Clear() {
541 // @@protoc_insertion_point(message_clear_start:perfetto.protos.PerfEvents.Timebase)
542   ::uint32_t cached_has_bits = 0;
543   // Prevent compiler warnings about cached_has_bits being unused
544   (void) cached_has_bits;
545 
546   cached_has_bits = _impl_._has_bits_[0];
547   if (cached_has_bits & 0x00000001u) {
548     _impl_.name_.ClearNonDefaultToEmpty();
549   }
550   _impl_.timestamp_clock_ = 0;
551   clear_interval();
552   clear_event();
553   _impl_._has_bits_.Clear();
554   _internal_metadata_.Clear<std::string>();
555 }
556 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)557 const char* PerfEvents_Timebase::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
558 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
559   _Internal::HasBits has_bits{};
560   while (!ctx->Done(&ptr)) {
561     ::uint32_t tag;
562     ptr = ::_pbi::ReadTag(ptr, &tag);
563     switch (tag >> 3) {
564       // uint64 period = 1;
565       case 1:
566         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
567           _internal_set_period(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
568           CHK_(ptr);
569         } else {
570           goto handle_unusual;
571         }
572         continue;
573       // uint64 frequency = 2;
574       case 2:
575         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
576           _internal_set_frequency(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr));
577           CHK_(ptr);
578         } else {
579           goto handle_unusual;
580         }
581         continue;
582       // .perfetto.protos.PerfEvents.Tracepoint tracepoint = 3;
583       case 3:
584         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
585           ptr = ctx->ParseMessage(_internal_mutable_tracepoint(), ptr);
586           CHK_(ptr);
587         } else {
588           goto handle_unusual;
589         }
590         continue;
591       // .perfetto.protos.PerfEvents.Counter counter = 4;
592       case 4:
593         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
594           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
595           CHK_(ptr);
596           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::PerfEvents_Counter_IsValid(val))) {
597             _internal_set_counter(static_cast<::perfetto::protos::PerfEvents_Counter>(val));
598           } else {
599             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(4, val, mutable_unknown_fields());
600           }
601         } else {
602           goto handle_unusual;
603         }
604         continue;
605       // .perfetto.protos.PerfEvents.RawEvent raw_event = 5;
606       case 5:
607         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 42)) {
608           ptr = ctx->ParseMessage(_internal_mutable_raw_event(), ptr);
609           CHK_(ptr);
610         } else {
611           goto handle_unusual;
612         }
613         continue;
614       // optional string name = 10;
615       case 10:
616         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 82)) {
617           auto str = _internal_mutable_name();
618           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
619           CHK_(ptr);
620         } else {
621           goto handle_unusual;
622         }
623         continue;
624       // optional .perfetto.protos.PerfEvents.PerfClock timestamp_clock = 11;
625       case 11:
626         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
627           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
628           CHK_(ptr);
629           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::PerfEvents_PerfClock_IsValid(val))) {
630             _internal_set_timestamp_clock(static_cast<::perfetto::protos::PerfEvents_PerfClock>(val));
631           } else {
632             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(11, val, mutable_unknown_fields());
633           }
634         } else {
635           goto handle_unusual;
636         }
637         continue;
638       default:
639         goto handle_unusual;
640     }  // switch
641   handle_unusual:
642     if ((tag == 0) || ((tag & 7) == 4)) {
643       CHK_(ptr);
644       ctx->SetLastTag(tag);
645       goto message_done;
646     }
647     ptr = UnknownFieldParse(
648         tag,
649         _internal_metadata_.mutable_unknown_fields<std::string>(),
650         ptr, ctx);
651     CHK_(ptr != nullptr);
652   }  // while
653 message_done:
654   _impl_._has_bits_.Or(has_bits);
655   return ptr;
656 failure:
657   ptr = nullptr;
658   goto message_done;
659 #undef CHK_
660 }
661 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const662 ::uint8_t* PerfEvents_Timebase::_InternalSerialize(
663     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
664   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.PerfEvents.Timebase)
665   ::uint32_t cached_has_bits = 0;
666   (void) cached_has_bits;
667 
668   switch (interval_case()) {
669     case kPeriod: {
670       target = stream->EnsureSpace(target);
671       target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_period(), target);
672       break;
673     }
674     case kFrequency: {
675       target = stream->EnsureSpace(target);
676       target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_frequency(), target);
677       break;
678     }
679     default: ;
680   }
681   switch (event_case()) {
682     case kTracepoint: {
683       target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
684         InternalWriteMessage(3, _Internal::tracepoint(this),
685           _Internal::tracepoint(this).GetCachedSize(), target, stream);
686       break;
687     }
688     case kCounter: {
689       target = stream->EnsureSpace(target);
690       target = ::_pbi::WireFormatLite::WriteEnumToArray(
691         4, this->_internal_counter(), target);
692       break;
693     }
694     case kRawEvent: {
695       target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
696         InternalWriteMessage(5, _Internal::raw_event(this),
697           _Internal::raw_event(this).GetCachedSize(), target, stream);
698       break;
699     }
700     default: ;
701   }
702   cached_has_bits = _impl_._has_bits_[0];
703   // optional string name = 10;
704   if (cached_has_bits & 0x00000001u) {
705     target = stream->WriteStringMaybeAliased(
706         10, this->_internal_name(), target);
707   }
708 
709   // optional .perfetto.protos.PerfEvents.PerfClock timestamp_clock = 11;
710   if (cached_has_bits & 0x00000002u) {
711     target = stream->EnsureSpace(target);
712     target = ::_pbi::WireFormatLite::WriteEnumToArray(
713       11, this->_internal_timestamp_clock(), target);
714   }
715 
716   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
717     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
718         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
719   }
720   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.PerfEvents.Timebase)
721   return target;
722 }
723 
ByteSizeLong() const724 size_t PerfEvents_Timebase::ByteSizeLong() const {
725 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.PerfEvents.Timebase)
726   size_t total_size = 0;
727 
728   ::uint32_t cached_has_bits = 0;
729   // Prevent compiler warnings about cached_has_bits being unused
730   (void) cached_has_bits;
731 
732   cached_has_bits = _impl_._has_bits_[0];
733   if (cached_has_bits & 0x00000003u) {
734     // optional string name = 10;
735     if (cached_has_bits & 0x00000001u) {
736       total_size += 1 +
737         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
738           this->_internal_name());
739     }
740 
741     // optional .perfetto.protos.PerfEvents.PerfClock timestamp_clock = 11;
742     if (cached_has_bits & 0x00000002u) {
743       total_size += 1 +
744         ::_pbi::WireFormatLite::EnumSize(this->_internal_timestamp_clock());
745     }
746 
747   }
748   switch (interval_case()) {
749     // uint64 frequency = 2;
750     case kFrequency: {
751       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_frequency());
752       break;
753     }
754     // uint64 period = 1;
755     case kPeriod: {
756       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_period());
757       break;
758     }
759     case INTERVAL_NOT_SET: {
760       break;
761     }
762   }
763   switch (event_case()) {
764     // .perfetto.protos.PerfEvents.Counter counter = 4;
765     case kCounter: {
766       total_size += 1 +
767         ::_pbi::WireFormatLite::EnumSize(this->_internal_counter());
768       break;
769     }
770     // .perfetto.protos.PerfEvents.Tracepoint tracepoint = 3;
771     case kTracepoint: {
772       total_size += 1 +
773         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
774           *_impl_.event_.tracepoint_);
775       break;
776     }
777     // .perfetto.protos.PerfEvents.RawEvent raw_event = 5;
778     case kRawEvent: {
779       total_size += 1 +
780         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
781           *_impl_.event_.raw_event_);
782       break;
783     }
784     case EVENT_NOT_SET: {
785       break;
786     }
787   }
788   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
789     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
790   }
791   int cached_size = ::_pbi::ToCachedSize(total_size);
792   SetCachedSize(cached_size);
793   return total_size;
794 }
795 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)796 void PerfEvents_Timebase::CheckTypeAndMergeFrom(
797     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
798   MergeFrom(*::_pbi::DownCast<const PerfEvents_Timebase*>(
799       &from));
800 }
801 
MergeFrom(const PerfEvents_Timebase & from)802 void PerfEvents_Timebase::MergeFrom(const PerfEvents_Timebase& from) {
803   PerfEvents_Timebase* const _this = this;
804   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.PerfEvents.Timebase)
805   GOOGLE_DCHECK_NE(&from, _this);
806   ::uint32_t cached_has_bits = 0;
807   (void) cached_has_bits;
808 
809   cached_has_bits = from._impl_._has_bits_[0];
810   if (cached_has_bits & 0x00000003u) {
811     if (cached_has_bits & 0x00000001u) {
812       _this->_internal_set_name(from._internal_name());
813     }
814     if (cached_has_bits & 0x00000002u) {
815       _this->_impl_.timestamp_clock_ = from._impl_.timestamp_clock_;
816     }
817     _this->_impl_._has_bits_[0] |= cached_has_bits;
818   }
819   switch (from.interval_case()) {
820     case kFrequency: {
821       _this->_internal_set_frequency(from._internal_frequency());
822       break;
823     }
824     case kPeriod: {
825       _this->_internal_set_period(from._internal_period());
826       break;
827     }
828     case INTERVAL_NOT_SET: {
829       break;
830     }
831   }
832   switch (from.event_case()) {
833     case kCounter: {
834       _this->_internal_set_counter(from._internal_counter());
835       break;
836     }
837     case kTracepoint: {
838       _this->_internal_mutable_tracepoint()->::perfetto::protos::PerfEvents_Tracepoint::MergeFrom(
839           from._internal_tracepoint());
840       break;
841     }
842     case kRawEvent: {
843       _this->_internal_mutable_raw_event()->::perfetto::protos::PerfEvents_RawEvent::MergeFrom(
844           from._internal_raw_event());
845       break;
846     }
847     case EVENT_NOT_SET: {
848       break;
849     }
850   }
851   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
852 }
853 
CopyFrom(const PerfEvents_Timebase & from)854 void PerfEvents_Timebase::CopyFrom(const PerfEvents_Timebase& from) {
855 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.PerfEvents.Timebase)
856   if (&from == this) return;
857   Clear();
858   MergeFrom(from);
859 }
860 
IsInitialized() const861 bool PerfEvents_Timebase::IsInitialized() const {
862   return true;
863 }
864 
InternalSwap(PerfEvents_Timebase * other)865 void PerfEvents_Timebase::InternalSwap(PerfEvents_Timebase* other) {
866   using std::swap;
867   auto* lhs_arena = GetArenaForAllocation();
868   auto* rhs_arena = other->GetArenaForAllocation();
869   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
870   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
871   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
872       &_impl_.name_, lhs_arena,
873       &other->_impl_.name_, rhs_arena
874   );
875   swap(_impl_.timestamp_clock_, other->_impl_.timestamp_clock_);
876   swap(_impl_.interval_, other->_impl_.interval_);
877   swap(_impl_.event_, other->_impl_.event_);
878   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
879   swap(_impl_._oneof_case_[1], other->_impl_._oneof_case_[1]);
880 }
881 
GetTypeName() const882 std::string PerfEvents_Timebase::GetTypeName() const {
883   return "perfetto.protos.PerfEvents.Timebase";
884 }
885 
886 
887 // ===================================================================
888 
889 class PerfEvents_Tracepoint::_Internal {
890  public:
891   using HasBits = decltype(std::declval<PerfEvents_Tracepoint>()._impl_._has_bits_);
set_has_name(HasBits * has_bits)892   static void set_has_name(HasBits* has_bits) {
893     (*has_bits)[0] |= 1u;
894   }
set_has_filter(HasBits * has_bits)895   static void set_has_filter(HasBits* has_bits) {
896     (*has_bits)[0] |= 2u;
897   }
898 };
899 
PerfEvents_Tracepoint(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)900 PerfEvents_Tracepoint::PerfEvents_Tracepoint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
901                          bool is_message_owned)
902   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
903   SharedCtor(arena, is_message_owned);
904   // @@protoc_insertion_point(arena_constructor:perfetto.protos.PerfEvents.Tracepoint)
905 }
PerfEvents_Tracepoint(const PerfEvents_Tracepoint & from)906 PerfEvents_Tracepoint::PerfEvents_Tracepoint(const PerfEvents_Tracepoint& from)
907   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
908   PerfEvents_Tracepoint* const _this = this; (void)_this;
909   new (&_impl_) Impl_{
910       decltype(_impl_._has_bits_){from._impl_._has_bits_}
911     , /*decltype(_impl_._cached_size_)*/{}
912     , decltype(_impl_.name_){}
913     , decltype(_impl_.filter_){}};
914 
915   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
916   _impl_.name_.InitDefault();
917   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
918     _impl_.name_.Set("", GetArenaForAllocation());
919   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
920   if (from._internal_has_name()) {
921     _this->_impl_.name_.Set(from._internal_name(),
922       _this->GetArenaForAllocation());
923   }
924   _impl_.filter_.InitDefault();
925   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
926     _impl_.filter_.Set("", GetArenaForAllocation());
927   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
928   if (from._internal_has_filter()) {
929     _this->_impl_.filter_.Set(from._internal_filter(),
930       _this->GetArenaForAllocation());
931   }
932   // @@protoc_insertion_point(copy_constructor:perfetto.protos.PerfEvents.Tracepoint)
933 }
934 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)935 inline void PerfEvents_Tracepoint::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_.name_){}
943     , decltype(_impl_.filter_){}
944   };
945   _impl_.name_.InitDefault();
946   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
947     _impl_.name_.Set("", GetArenaForAllocation());
948   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
949   _impl_.filter_.InitDefault();
950   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
951     _impl_.filter_.Set("", GetArenaForAllocation());
952   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
953 }
954 
~PerfEvents_Tracepoint()955 PerfEvents_Tracepoint::~PerfEvents_Tracepoint() {
956   // @@protoc_insertion_point(destructor:perfetto.protos.PerfEvents.Tracepoint)
957   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
958   (void)arena;
959     return;
960   }
961   SharedDtor();
962 }
963 
SharedDtor()964 inline void PerfEvents_Tracepoint::SharedDtor() {
965   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
966   _impl_.name_.Destroy();
967   _impl_.filter_.Destroy();
968 }
969 
SetCachedSize(int size) const970 void PerfEvents_Tracepoint::SetCachedSize(int size) const {
971   _impl_._cached_size_.Set(size);
972 }
973 
Clear()974 void PerfEvents_Tracepoint::Clear() {
975 // @@protoc_insertion_point(message_clear_start:perfetto.protos.PerfEvents.Tracepoint)
976   ::uint32_t cached_has_bits = 0;
977   // Prevent compiler warnings about cached_has_bits being unused
978   (void) cached_has_bits;
979 
980   cached_has_bits = _impl_._has_bits_[0];
981   if (cached_has_bits & 0x00000003u) {
982     if (cached_has_bits & 0x00000001u) {
983       _impl_.name_.ClearNonDefaultToEmpty();
984     }
985     if (cached_has_bits & 0x00000002u) {
986       _impl_.filter_.ClearNonDefaultToEmpty();
987     }
988   }
989   _impl_._has_bits_.Clear();
990   _internal_metadata_.Clear<std::string>();
991 }
992 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)993 const char* PerfEvents_Tracepoint::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
994 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
995   _Internal::HasBits has_bits{};
996   while (!ctx->Done(&ptr)) {
997     ::uint32_t tag;
998     ptr = ::_pbi::ReadTag(ptr, &tag);
999     switch (tag >> 3) {
1000       // optional string name = 1;
1001       case 1:
1002         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
1003           auto str = _internal_mutable_name();
1004           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1005           CHK_(ptr);
1006         } else {
1007           goto handle_unusual;
1008         }
1009         continue;
1010       // optional string filter = 2;
1011       case 2:
1012         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1013           auto str = _internal_mutable_filter();
1014           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1015           CHK_(ptr);
1016         } else {
1017           goto handle_unusual;
1018         }
1019         continue;
1020       default:
1021         goto handle_unusual;
1022     }  // switch
1023   handle_unusual:
1024     if ((tag == 0) || ((tag & 7) == 4)) {
1025       CHK_(ptr);
1026       ctx->SetLastTag(tag);
1027       goto message_done;
1028     }
1029     ptr = UnknownFieldParse(
1030         tag,
1031         _internal_metadata_.mutable_unknown_fields<std::string>(),
1032         ptr, ctx);
1033     CHK_(ptr != nullptr);
1034   }  // while
1035 message_done:
1036   _impl_._has_bits_.Or(has_bits);
1037   return ptr;
1038 failure:
1039   ptr = nullptr;
1040   goto message_done;
1041 #undef CHK_
1042 }
1043 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1044 ::uint8_t* PerfEvents_Tracepoint::_InternalSerialize(
1045     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1046   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.PerfEvents.Tracepoint)
1047   ::uint32_t cached_has_bits = 0;
1048   (void) cached_has_bits;
1049 
1050   cached_has_bits = _impl_._has_bits_[0];
1051   // optional string name = 1;
1052   if (cached_has_bits & 0x00000001u) {
1053     target = stream->WriteStringMaybeAliased(
1054         1, this->_internal_name(), target);
1055   }
1056 
1057   // optional string filter = 2;
1058   if (cached_has_bits & 0x00000002u) {
1059     target = stream->WriteStringMaybeAliased(
1060         2, this->_internal_filter(), target);
1061   }
1062 
1063   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1064     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1065         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1066   }
1067   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.PerfEvents.Tracepoint)
1068   return target;
1069 }
1070 
ByteSizeLong() const1071 size_t PerfEvents_Tracepoint::ByteSizeLong() const {
1072 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.PerfEvents.Tracepoint)
1073   size_t total_size = 0;
1074 
1075   ::uint32_t cached_has_bits = 0;
1076   // Prevent compiler warnings about cached_has_bits being unused
1077   (void) cached_has_bits;
1078 
1079   cached_has_bits = _impl_._has_bits_[0];
1080   if (cached_has_bits & 0x00000003u) {
1081     // optional string name = 1;
1082     if (cached_has_bits & 0x00000001u) {
1083       total_size += 1 +
1084         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1085           this->_internal_name());
1086     }
1087 
1088     // optional string filter = 2;
1089     if (cached_has_bits & 0x00000002u) {
1090       total_size += 1 +
1091         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1092           this->_internal_filter());
1093     }
1094 
1095   }
1096   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1097     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1098   }
1099   int cached_size = ::_pbi::ToCachedSize(total_size);
1100   SetCachedSize(cached_size);
1101   return total_size;
1102 }
1103 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1104 void PerfEvents_Tracepoint::CheckTypeAndMergeFrom(
1105     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1106   MergeFrom(*::_pbi::DownCast<const PerfEvents_Tracepoint*>(
1107       &from));
1108 }
1109 
MergeFrom(const PerfEvents_Tracepoint & from)1110 void PerfEvents_Tracepoint::MergeFrom(const PerfEvents_Tracepoint& from) {
1111   PerfEvents_Tracepoint* const _this = this;
1112   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.PerfEvents.Tracepoint)
1113   GOOGLE_DCHECK_NE(&from, _this);
1114   ::uint32_t cached_has_bits = 0;
1115   (void) cached_has_bits;
1116 
1117   cached_has_bits = from._impl_._has_bits_[0];
1118   if (cached_has_bits & 0x00000003u) {
1119     if (cached_has_bits & 0x00000001u) {
1120       _this->_internal_set_name(from._internal_name());
1121     }
1122     if (cached_has_bits & 0x00000002u) {
1123       _this->_internal_set_filter(from._internal_filter());
1124     }
1125   }
1126   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1127 }
1128 
CopyFrom(const PerfEvents_Tracepoint & from)1129 void PerfEvents_Tracepoint::CopyFrom(const PerfEvents_Tracepoint& from) {
1130 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.PerfEvents.Tracepoint)
1131   if (&from == this) return;
1132   Clear();
1133   MergeFrom(from);
1134 }
1135 
IsInitialized() const1136 bool PerfEvents_Tracepoint::IsInitialized() const {
1137   return true;
1138 }
1139 
InternalSwap(PerfEvents_Tracepoint * other)1140 void PerfEvents_Tracepoint::InternalSwap(PerfEvents_Tracepoint* other) {
1141   using std::swap;
1142   auto* lhs_arena = GetArenaForAllocation();
1143   auto* rhs_arena = other->GetArenaForAllocation();
1144   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1145   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1146   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1147       &_impl_.name_, lhs_arena,
1148       &other->_impl_.name_, rhs_arena
1149   );
1150   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
1151       &_impl_.filter_, lhs_arena,
1152       &other->_impl_.filter_, rhs_arena
1153   );
1154 }
1155 
GetTypeName() const1156 std::string PerfEvents_Tracepoint::GetTypeName() const {
1157   return "perfetto.protos.PerfEvents.Tracepoint";
1158 }
1159 
1160 
1161 // ===================================================================
1162 
1163 class PerfEvents_RawEvent::_Internal {
1164  public:
1165   using HasBits = decltype(std::declval<PerfEvents_RawEvent>()._impl_._has_bits_);
set_has_type(HasBits * has_bits)1166   static void set_has_type(HasBits* has_bits) {
1167     (*has_bits)[0] |= 8u;
1168   }
set_has_config(HasBits * has_bits)1169   static void set_has_config(HasBits* has_bits) {
1170     (*has_bits)[0] |= 1u;
1171   }
set_has_config1(HasBits * has_bits)1172   static void set_has_config1(HasBits* has_bits) {
1173     (*has_bits)[0] |= 2u;
1174   }
set_has_config2(HasBits * has_bits)1175   static void set_has_config2(HasBits* has_bits) {
1176     (*has_bits)[0] |= 4u;
1177   }
1178 };
1179 
PerfEvents_RawEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1180 PerfEvents_RawEvent::PerfEvents_RawEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1181                          bool is_message_owned)
1182   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1183   SharedCtor(arena, is_message_owned);
1184   // @@protoc_insertion_point(arena_constructor:perfetto.protos.PerfEvents.RawEvent)
1185 }
PerfEvents_RawEvent(const PerfEvents_RawEvent & from)1186 PerfEvents_RawEvent::PerfEvents_RawEvent(const PerfEvents_RawEvent& from)
1187   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1188   PerfEvents_RawEvent* const _this = this; (void)_this;
1189   new (&_impl_) Impl_{
1190       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1191     , /*decltype(_impl_._cached_size_)*/{}
1192     , decltype(_impl_.config_){}
1193     , decltype(_impl_.config1_){}
1194     , decltype(_impl_.config2_){}
1195     , decltype(_impl_.type_){}};
1196 
1197   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1198   ::memcpy(&_impl_.config_, &from._impl_.config_,
1199     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.type_) -
1200     reinterpret_cast<char*>(&_impl_.config_)) + sizeof(_impl_.type_));
1201   // @@protoc_insertion_point(copy_constructor:perfetto.protos.PerfEvents.RawEvent)
1202 }
1203 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1204 inline void PerfEvents_RawEvent::SharedCtor(
1205     ::_pb::Arena* arena, bool is_message_owned) {
1206   (void)arena;
1207   (void)is_message_owned;
1208   new (&_impl_) Impl_{
1209       decltype(_impl_._has_bits_){}
1210     , /*decltype(_impl_._cached_size_)*/{}
1211     , decltype(_impl_.config_){::uint64_t{0u}}
1212     , decltype(_impl_.config1_){::uint64_t{0u}}
1213     , decltype(_impl_.config2_){::uint64_t{0u}}
1214     , decltype(_impl_.type_){0u}
1215   };
1216 }
1217 
~PerfEvents_RawEvent()1218 PerfEvents_RawEvent::~PerfEvents_RawEvent() {
1219   // @@protoc_insertion_point(destructor:perfetto.protos.PerfEvents.RawEvent)
1220   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1221   (void)arena;
1222     return;
1223   }
1224   SharedDtor();
1225 }
1226 
SharedDtor()1227 inline void PerfEvents_RawEvent::SharedDtor() {
1228   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1229 }
1230 
SetCachedSize(int size) const1231 void PerfEvents_RawEvent::SetCachedSize(int size) const {
1232   _impl_._cached_size_.Set(size);
1233 }
1234 
Clear()1235 void PerfEvents_RawEvent::Clear() {
1236 // @@protoc_insertion_point(message_clear_start:perfetto.protos.PerfEvents.RawEvent)
1237   ::uint32_t cached_has_bits = 0;
1238   // Prevent compiler warnings about cached_has_bits being unused
1239   (void) cached_has_bits;
1240 
1241   cached_has_bits = _impl_._has_bits_[0];
1242   if (cached_has_bits & 0x0000000fu) {
1243     ::memset(&_impl_.config_, 0, static_cast<size_t>(
1244         reinterpret_cast<char*>(&_impl_.type_) -
1245         reinterpret_cast<char*>(&_impl_.config_)) + sizeof(_impl_.type_));
1246   }
1247   _impl_._has_bits_.Clear();
1248   _internal_metadata_.Clear<std::string>();
1249 }
1250 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1251 const char* PerfEvents_RawEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1252 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1253   _Internal::HasBits has_bits{};
1254   while (!ctx->Done(&ptr)) {
1255     ::uint32_t tag;
1256     ptr = ::_pbi::ReadTag(ptr, &tag);
1257     switch (tag >> 3) {
1258       // optional uint32 type = 1;
1259       case 1:
1260         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1261           _Internal::set_has_type(&has_bits);
1262           _impl_.type_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1263           CHK_(ptr);
1264         } else {
1265           goto handle_unusual;
1266         }
1267         continue;
1268       // optional uint64 config = 2;
1269       case 2:
1270         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1271           _Internal::set_has_config(&has_bits);
1272           _impl_.config_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1273           CHK_(ptr);
1274         } else {
1275           goto handle_unusual;
1276         }
1277         continue;
1278       // optional uint64 config1 = 3;
1279       case 3:
1280         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1281           _Internal::set_has_config1(&has_bits);
1282           _impl_.config1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1283           CHK_(ptr);
1284         } else {
1285           goto handle_unusual;
1286         }
1287         continue;
1288       // optional uint64 config2 = 4;
1289       case 4:
1290         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1291           _Internal::set_has_config2(&has_bits);
1292           _impl_.config2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1293           CHK_(ptr);
1294         } else {
1295           goto handle_unusual;
1296         }
1297         continue;
1298       default:
1299         goto handle_unusual;
1300     }  // switch
1301   handle_unusual:
1302     if ((tag == 0) || ((tag & 7) == 4)) {
1303       CHK_(ptr);
1304       ctx->SetLastTag(tag);
1305       goto message_done;
1306     }
1307     ptr = UnknownFieldParse(
1308         tag,
1309         _internal_metadata_.mutable_unknown_fields<std::string>(),
1310         ptr, ctx);
1311     CHK_(ptr != nullptr);
1312   }  // while
1313 message_done:
1314   _impl_._has_bits_.Or(has_bits);
1315   return ptr;
1316 failure:
1317   ptr = nullptr;
1318   goto message_done;
1319 #undef CHK_
1320 }
1321 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1322 ::uint8_t* PerfEvents_RawEvent::_InternalSerialize(
1323     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1324   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.PerfEvents.RawEvent)
1325   ::uint32_t cached_has_bits = 0;
1326   (void) cached_has_bits;
1327 
1328   cached_has_bits = _impl_._has_bits_[0];
1329   // optional uint32 type = 1;
1330   if (cached_has_bits & 0x00000008u) {
1331     target = stream->EnsureSpace(target);
1332     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_type(), target);
1333   }
1334 
1335   // optional uint64 config = 2;
1336   if (cached_has_bits & 0x00000001u) {
1337     target = stream->EnsureSpace(target);
1338     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_config(), target);
1339   }
1340 
1341   // optional uint64 config1 = 3;
1342   if (cached_has_bits & 0x00000002u) {
1343     target = stream->EnsureSpace(target);
1344     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_config1(), target);
1345   }
1346 
1347   // optional uint64 config2 = 4;
1348   if (cached_has_bits & 0x00000004u) {
1349     target = stream->EnsureSpace(target);
1350     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_config2(), target);
1351   }
1352 
1353   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1354     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1355         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1356   }
1357   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.PerfEvents.RawEvent)
1358   return target;
1359 }
1360 
ByteSizeLong() const1361 size_t PerfEvents_RawEvent::ByteSizeLong() const {
1362 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.PerfEvents.RawEvent)
1363   size_t total_size = 0;
1364 
1365   ::uint32_t cached_has_bits = 0;
1366   // Prevent compiler warnings about cached_has_bits being unused
1367   (void) cached_has_bits;
1368 
1369   cached_has_bits = _impl_._has_bits_[0];
1370   if (cached_has_bits & 0x0000000fu) {
1371     // optional uint64 config = 2;
1372     if (cached_has_bits & 0x00000001u) {
1373       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_config());
1374     }
1375 
1376     // optional uint64 config1 = 3;
1377     if (cached_has_bits & 0x00000002u) {
1378       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_config1());
1379     }
1380 
1381     // optional uint64 config2 = 4;
1382     if (cached_has_bits & 0x00000004u) {
1383       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_config2());
1384     }
1385 
1386     // optional uint32 type = 1;
1387     if (cached_has_bits & 0x00000008u) {
1388       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_type());
1389     }
1390 
1391   }
1392   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1393     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1394   }
1395   int cached_size = ::_pbi::ToCachedSize(total_size);
1396   SetCachedSize(cached_size);
1397   return total_size;
1398 }
1399 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1400 void PerfEvents_RawEvent::CheckTypeAndMergeFrom(
1401     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1402   MergeFrom(*::_pbi::DownCast<const PerfEvents_RawEvent*>(
1403       &from));
1404 }
1405 
MergeFrom(const PerfEvents_RawEvent & from)1406 void PerfEvents_RawEvent::MergeFrom(const PerfEvents_RawEvent& from) {
1407   PerfEvents_RawEvent* const _this = this;
1408   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.PerfEvents.RawEvent)
1409   GOOGLE_DCHECK_NE(&from, _this);
1410   ::uint32_t cached_has_bits = 0;
1411   (void) cached_has_bits;
1412 
1413   cached_has_bits = from._impl_._has_bits_[0];
1414   if (cached_has_bits & 0x0000000fu) {
1415     if (cached_has_bits & 0x00000001u) {
1416       _this->_impl_.config_ = from._impl_.config_;
1417     }
1418     if (cached_has_bits & 0x00000002u) {
1419       _this->_impl_.config1_ = from._impl_.config1_;
1420     }
1421     if (cached_has_bits & 0x00000004u) {
1422       _this->_impl_.config2_ = from._impl_.config2_;
1423     }
1424     if (cached_has_bits & 0x00000008u) {
1425       _this->_impl_.type_ = from._impl_.type_;
1426     }
1427     _this->_impl_._has_bits_[0] |= cached_has_bits;
1428   }
1429   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1430 }
1431 
CopyFrom(const PerfEvents_RawEvent & from)1432 void PerfEvents_RawEvent::CopyFrom(const PerfEvents_RawEvent& from) {
1433 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.PerfEvents.RawEvent)
1434   if (&from == this) return;
1435   Clear();
1436   MergeFrom(from);
1437 }
1438 
IsInitialized() const1439 bool PerfEvents_RawEvent::IsInitialized() const {
1440   return true;
1441 }
1442 
InternalSwap(PerfEvents_RawEvent * other)1443 void PerfEvents_RawEvent::InternalSwap(PerfEvents_RawEvent* other) {
1444   using std::swap;
1445   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1446   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1447   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1448       PROTOBUF_FIELD_OFFSET(PerfEvents_RawEvent, _impl_.type_)
1449       + sizeof(PerfEvents_RawEvent::_impl_.type_)  // NOLINT
1450       - PROTOBUF_FIELD_OFFSET(PerfEvents_RawEvent, _impl_.config_)>(
1451           reinterpret_cast<char*>(&_impl_.config_),
1452           reinterpret_cast<char*>(&other->_impl_.config_));
1453 }
1454 
GetTypeName() const1455 std::string PerfEvents_RawEvent::GetTypeName() const {
1456   return "perfetto.protos.PerfEvents.RawEvent";
1457 }
1458 
1459 
1460 // ===================================================================
1461 
1462 class PerfEvents::_Internal {
1463  public:
1464 };
1465 
PerfEvents(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1466 PerfEvents::PerfEvents(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1467                          bool is_message_owned)
1468   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1469   SharedCtor(arena, is_message_owned);
1470   // @@protoc_insertion_point(arena_constructor:perfetto.protos.PerfEvents)
1471 }
PerfEvents(const PerfEvents & from)1472 PerfEvents::PerfEvents(const PerfEvents& from)
1473   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1474   PerfEvents* const _this = this; (void)_this;
1475   new (&_impl_) Impl_{
1476       /*decltype(_impl_._cached_size_)*/{}};
1477 
1478   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1479   // @@protoc_insertion_point(copy_constructor:perfetto.protos.PerfEvents)
1480 }
1481 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1482 inline void PerfEvents::SharedCtor(
1483     ::_pb::Arena* arena, bool is_message_owned) {
1484   (void)arena;
1485   (void)is_message_owned;
1486   new (&_impl_) Impl_{
1487       /*decltype(_impl_._cached_size_)*/{}
1488   };
1489 }
1490 
~PerfEvents()1491 PerfEvents::~PerfEvents() {
1492   // @@protoc_insertion_point(destructor:perfetto.protos.PerfEvents)
1493   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1494   (void)arena;
1495     return;
1496   }
1497   SharedDtor();
1498 }
1499 
SharedDtor()1500 inline void PerfEvents::SharedDtor() {
1501   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1502 }
1503 
SetCachedSize(int size) const1504 void PerfEvents::SetCachedSize(int size) const {
1505   _impl_._cached_size_.Set(size);
1506 }
1507 
Clear()1508 void PerfEvents::Clear() {
1509 // @@protoc_insertion_point(message_clear_start:perfetto.protos.PerfEvents)
1510   ::uint32_t cached_has_bits = 0;
1511   // Prevent compiler warnings about cached_has_bits being unused
1512   (void) cached_has_bits;
1513 
1514   _internal_metadata_.Clear<std::string>();
1515 }
1516 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1517 const char* PerfEvents::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1518 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1519   while (!ctx->Done(&ptr)) {
1520     ::uint32_t tag;
1521     ptr = ::_pbi::ReadTag(ptr, &tag);
1522     if ((tag == 0) || ((tag & 7) == 4)) {
1523       CHK_(ptr);
1524       ctx->SetLastTag(tag);
1525       goto message_done;
1526     }
1527     ptr = UnknownFieldParse(
1528         tag,
1529         _internal_metadata_.mutable_unknown_fields<std::string>(),
1530         ptr, ctx);
1531     CHK_(ptr != nullptr);
1532   }  // while
1533 message_done:
1534   return ptr;
1535 failure:
1536   ptr = nullptr;
1537   goto message_done;
1538 #undef CHK_
1539 }
1540 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1541 ::uint8_t* PerfEvents::_InternalSerialize(
1542     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1543   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.PerfEvents)
1544   ::uint32_t cached_has_bits = 0;
1545   (void) cached_has_bits;
1546 
1547   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1548     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1549         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1550   }
1551   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.PerfEvents)
1552   return target;
1553 }
1554 
ByteSizeLong() const1555 size_t PerfEvents::ByteSizeLong() const {
1556 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.PerfEvents)
1557   size_t total_size = 0;
1558 
1559   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1560     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1561   }
1562   int cached_size = ::_pbi::ToCachedSize(total_size);
1563   SetCachedSize(cached_size);
1564   return total_size;
1565 }
1566 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1567 void PerfEvents::CheckTypeAndMergeFrom(
1568     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1569   MergeFrom(*::_pbi::DownCast<const PerfEvents*>(
1570       &from));
1571 }
1572 
MergeFrom(const PerfEvents & from)1573 void PerfEvents::MergeFrom(const PerfEvents& from) {
1574   PerfEvents* const _this = this;
1575   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.PerfEvents)
1576   GOOGLE_DCHECK_NE(&from, _this);
1577   ::uint32_t cached_has_bits = 0;
1578   (void) cached_has_bits;
1579 
1580   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1581 }
1582 
CopyFrom(const PerfEvents & from)1583 void PerfEvents::CopyFrom(const PerfEvents& from) {
1584 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.PerfEvents)
1585   if (&from == this) return;
1586   Clear();
1587   MergeFrom(from);
1588 }
1589 
IsInitialized() const1590 bool PerfEvents::IsInitialized() const {
1591   return true;
1592 }
1593 
InternalSwap(PerfEvents * other)1594 void PerfEvents::InternalSwap(PerfEvents* other) {
1595   using std::swap;
1596   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1597 }
1598 
GetTypeName() const1599 std::string PerfEvents::GetTypeName() const {
1600   return "perfetto.protos.PerfEvents";
1601 }
1602 
1603 
1604 // ===================================================================
1605 
1606 class FollowerEvent::_Internal {
1607  public:
1608   using HasBits = decltype(std::declval<FollowerEvent>()._impl_._has_bits_);
1609   static const ::perfetto::protos::PerfEvents_Tracepoint& tracepoint(const FollowerEvent* msg);
1610   static const ::perfetto::protos::PerfEvents_RawEvent& raw_event(const FollowerEvent* msg);
set_has_name(HasBits * has_bits)1611   static void set_has_name(HasBits* has_bits) {
1612     (*has_bits)[0] |= 1u;
1613   }
1614 };
1615 
1616 const ::perfetto::protos::PerfEvents_Tracepoint&
tracepoint(const FollowerEvent * msg)1617 FollowerEvent::_Internal::tracepoint(const FollowerEvent* msg) {
1618   return *msg->_impl_.event_.tracepoint_;
1619 }
1620 const ::perfetto::protos::PerfEvents_RawEvent&
raw_event(const FollowerEvent * msg)1621 FollowerEvent::_Internal::raw_event(const FollowerEvent* msg) {
1622   return *msg->_impl_.event_.raw_event_;
1623 }
set_allocated_tracepoint(::perfetto::protos::PerfEvents_Tracepoint * tracepoint)1624 void FollowerEvent::set_allocated_tracepoint(::perfetto::protos::PerfEvents_Tracepoint* tracepoint) {
1625   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1626   clear_event();
1627   if (tracepoint) {
1628     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1629       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(tracepoint);
1630     if (message_arena != submessage_arena) {
1631       tracepoint = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1632           message_arena, tracepoint, submessage_arena);
1633     }
1634     set_has_tracepoint();
1635     _impl_.event_.tracepoint_ = tracepoint;
1636   }
1637   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FollowerEvent.tracepoint)
1638 }
set_allocated_raw_event(::perfetto::protos::PerfEvents_RawEvent * raw_event)1639 void FollowerEvent::set_allocated_raw_event(::perfetto::protos::PerfEvents_RawEvent* raw_event) {
1640   ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
1641   clear_event();
1642   if (raw_event) {
1643     ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
1644       ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(raw_event);
1645     if (message_arena != submessage_arena) {
1646       raw_event = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
1647           message_arena, raw_event, submessage_arena);
1648     }
1649     set_has_raw_event();
1650     _impl_.event_.raw_event_ = raw_event;
1651   }
1652   // @@protoc_insertion_point(field_set_allocated:perfetto.protos.FollowerEvent.raw_event)
1653 }
FollowerEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1654 FollowerEvent::FollowerEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1655                          bool is_message_owned)
1656   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1657   SharedCtor(arena, is_message_owned);
1658   // @@protoc_insertion_point(arena_constructor:perfetto.protos.FollowerEvent)
1659 }
FollowerEvent(const FollowerEvent & from)1660 FollowerEvent::FollowerEvent(const FollowerEvent& from)
1661   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1662   FollowerEvent* const _this = this; (void)_this;
1663   new (&_impl_) Impl_{
1664       decltype(_impl_._has_bits_){from._impl_._has_bits_}
1665     , /*decltype(_impl_._cached_size_)*/{}
1666     , decltype(_impl_.name_){}
1667     , decltype(_impl_.event_){}
1668     , /*decltype(_impl_._oneof_case_)*/{}};
1669 
1670   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1671   _impl_.name_.InitDefault();
1672   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1673     _impl_.name_.Set("", GetArenaForAllocation());
1674   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1675   if (from._internal_has_name()) {
1676     _this->_impl_.name_.Set(from._internal_name(),
1677       _this->GetArenaForAllocation());
1678   }
1679   clear_has_event();
1680   switch (from.event_case()) {
1681     case kCounter: {
1682       _this->_internal_set_counter(from._internal_counter());
1683       break;
1684     }
1685     case kTracepoint: {
1686       _this->_internal_mutable_tracepoint()->::perfetto::protos::PerfEvents_Tracepoint::MergeFrom(
1687           from._internal_tracepoint());
1688       break;
1689     }
1690     case kRawEvent: {
1691       _this->_internal_mutable_raw_event()->::perfetto::protos::PerfEvents_RawEvent::MergeFrom(
1692           from._internal_raw_event());
1693       break;
1694     }
1695     case EVENT_NOT_SET: {
1696       break;
1697     }
1698   }
1699   // @@protoc_insertion_point(copy_constructor:perfetto.protos.FollowerEvent)
1700 }
1701 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1702 inline void FollowerEvent::SharedCtor(
1703     ::_pb::Arena* arena, bool is_message_owned) {
1704   (void)arena;
1705   (void)is_message_owned;
1706   new (&_impl_) Impl_{
1707       decltype(_impl_._has_bits_){}
1708     , /*decltype(_impl_._cached_size_)*/{}
1709     , decltype(_impl_.name_){}
1710     , decltype(_impl_.event_){}
1711     , /*decltype(_impl_._oneof_case_)*/{}
1712   };
1713   _impl_.name_.InitDefault();
1714   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
1715     _impl_.name_.Set("", GetArenaForAllocation());
1716   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
1717   clear_has_event();
1718 }
1719 
~FollowerEvent()1720 FollowerEvent::~FollowerEvent() {
1721   // @@protoc_insertion_point(destructor:perfetto.protos.FollowerEvent)
1722   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1723   (void)arena;
1724     return;
1725   }
1726   SharedDtor();
1727 }
1728 
SharedDtor()1729 inline void FollowerEvent::SharedDtor() {
1730   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1731   _impl_.name_.Destroy();
1732   if (has_event()) {
1733     clear_event();
1734   }
1735 }
1736 
SetCachedSize(int size) const1737 void FollowerEvent::SetCachedSize(int size) const {
1738   _impl_._cached_size_.Set(size);
1739 }
1740 
clear_event()1741 void FollowerEvent::clear_event() {
1742 // @@protoc_insertion_point(one_of_clear_start:perfetto.protos.FollowerEvent)
1743   switch (event_case()) {
1744     case kCounter: {
1745       // No need to clear
1746       break;
1747     }
1748     case kTracepoint: {
1749       if (GetArenaForAllocation() == nullptr) {
1750         delete _impl_.event_.tracepoint_;
1751       }
1752       break;
1753     }
1754     case kRawEvent: {
1755       if (GetArenaForAllocation() == nullptr) {
1756         delete _impl_.event_.raw_event_;
1757       }
1758       break;
1759     }
1760     case EVENT_NOT_SET: {
1761       break;
1762     }
1763   }
1764   _impl_._oneof_case_[0] = EVENT_NOT_SET;
1765 }
1766 
1767 
Clear()1768 void FollowerEvent::Clear() {
1769 // @@protoc_insertion_point(message_clear_start:perfetto.protos.FollowerEvent)
1770   ::uint32_t cached_has_bits = 0;
1771   // Prevent compiler warnings about cached_has_bits being unused
1772   (void) cached_has_bits;
1773 
1774   cached_has_bits = _impl_._has_bits_[0];
1775   if (cached_has_bits & 0x00000001u) {
1776     _impl_.name_.ClearNonDefaultToEmpty();
1777   }
1778   clear_event();
1779   _impl_._has_bits_.Clear();
1780   _internal_metadata_.Clear<std::string>();
1781 }
1782 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1783 const char* FollowerEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1784 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1785   _Internal::HasBits has_bits{};
1786   while (!ctx->Done(&ptr)) {
1787     ::uint32_t tag;
1788     ptr = ::_pbi::ReadTag(ptr, &tag);
1789     switch (tag >> 3) {
1790       // .perfetto.protos.PerfEvents.Counter counter = 1;
1791       case 1:
1792         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1793           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1794           CHK_(ptr);
1795           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::PerfEvents_Counter_IsValid(val))) {
1796             _internal_set_counter(static_cast<::perfetto::protos::PerfEvents_Counter>(val));
1797           } else {
1798             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
1799           }
1800         } else {
1801           goto handle_unusual;
1802         }
1803         continue;
1804       // .perfetto.protos.PerfEvents.Tracepoint tracepoint = 2;
1805       case 2:
1806         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
1807           ptr = ctx->ParseMessage(_internal_mutable_tracepoint(), ptr);
1808           CHK_(ptr);
1809         } else {
1810           goto handle_unusual;
1811         }
1812         continue;
1813       // .perfetto.protos.PerfEvents.RawEvent raw_event = 3;
1814       case 3:
1815         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
1816           ptr = ctx->ParseMessage(_internal_mutable_raw_event(), ptr);
1817           CHK_(ptr);
1818         } else {
1819           goto handle_unusual;
1820         }
1821         continue;
1822       // optional string name = 4;
1823       case 4:
1824         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 34)) {
1825           auto str = _internal_mutable_name();
1826           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
1827           CHK_(ptr);
1828         } else {
1829           goto handle_unusual;
1830         }
1831         continue;
1832       default:
1833         goto handle_unusual;
1834     }  // switch
1835   handle_unusual:
1836     if ((tag == 0) || ((tag & 7) == 4)) {
1837       CHK_(ptr);
1838       ctx->SetLastTag(tag);
1839       goto message_done;
1840     }
1841     ptr = UnknownFieldParse(
1842         tag,
1843         _internal_metadata_.mutable_unknown_fields<std::string>(),
1844         ptr, ctx);
1845     CHK_(ptr != nullptr);
1846   }  // while
1847 message_done:
1848   _impl_._has_bits_.Or(has_bits);
1849   return ptr;
1850 failure:
1851   ptr = nullptr;
1852   goto message_done;
1853 #undef CHK_
1854 }
1855 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1856 ::uint8_t* FollowerEvent::_InternalSerialize(
1857     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1858   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.FollowerEvent)
1859   ::uint32_t cached_has_bits = 0;
1860   (void) cached_has_bits;
1861 
1862   switch (event_case()) {
1863     case kCounter: {
1864       target = stream->EnsureSpace(target);
1865       target = ::_pbi::WireFormatLite::WriteEnumToArray(
1866         1, this->_internal_counter(), target);
1867       break;
1868     }
1869     case kTracepoint: {
1870       target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1871         InternalWriteMessage(2, _Internal::tracepoint(this),
1872           _Internal::tracepoint(this).GetCachedSize(), target, stream);
1873       break;
1874     }
1875     case kRawEvent: {
1876       target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
1877         InternalWriteMessage(3, _Internal::raw_event(this),
1878           _Internal::raw_event(this).GetCachedSize(), target, stream);
1879       break;
1880     }
1881     default: ;
1882   }
1883   cached_has_bits = _impl_._has_bits_[0];
1884   // optional string name = 4;
1885   if (cached_has_bits & 0x00000001u) {
1886     target = stream->WriteStringMaybeAliased(
1887         4, this->_internal_name(), target);
1888   }
1889 
1890   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1891     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1892         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1893   }
1894   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.FollowerEvent)
1895   return target;
1896 }
1897 
ByteSizeLong() const1898 size_t FollowerEvent::ByteSizeLong() const {
1899 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.FollowerEvent)
1900   size_t total_size = 0;
1901 
1902   ::uint32_t cached_has_bits = 0;
1903   // Prevent compiler warnings about cached_has_bits being unused
1904   (void) cached_has_bits;
1905 
1906   // optional string name = 4;
1907   cached_has_bits = _impl_._has_bits_[0];
1908   if (cached_has_bits & 0x00000001u) {
1909     total_size += 1 +
1910       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
1911         this->_internal_name());
1912   }
1913 
1914   switch (event_case()) {
1915     // .perfetto.protos.PerfEvents.Counter counter = 1;
1916     case kCounter: {
1917       total_size += 1 +
1918         ::_pbi::WireFormatLite::EnumSize(this->_internal_counter());
1919       break;
1920     }
1921     // .perfetto.protos.PerfEvents.Tracepoint tracepoint = 2;
1922     case kTracepoint: {
1923       total_size += 1 +
1924         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1925           *_impl_.event_.tracepoint_);
1926       break;
1927     }
1928     // .perfetto.protos.PerfEvents.RawEvent raw_event = 3;
1929     case kRawEvent: {
1930       total_size += 1 +
1931         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
1932           *_impl_.event_.raw_event_);
1933       break;
1934     }
1935     case EVENT_NOT_SET: {
1936       break;
1937     }
1938   }
1939   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1940     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1941   }
1942   int cached_size = ::_pbi::ToCachedSize(total_size);
1943   SetCachedSize(cached_size);
1944   return total_size;
1945 }
1946 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1947 void FollowerEvent::CheckTypeAndMergeFrom(
1948     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1949   MergeFrom(*::_pbi::DownCast<const FollowerEvent*>(
1950       &from));
1951 }
1952 
MergeFrom(const FollowerEvent & from)1953 void FollowerEvent::MergeFrom(const FollowerEvent& from) {
1954   FollowerEvent* const _this = this;
1955   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.FollowerEvent)
1956   GOOGLE_DCHECK_NE(&from, _this);
1957   ::uint32_t cached_has_bits = 0;
1958   (void) cached_has_bits;
1959 
1960   if (from._internal_has_name()) {
1961     _this->_internal_set_name(from._internal_name());
1962   }
1963   switch (from.event_case()) {
1964     case kCounter: {
1965       _this->_internal_set_counter(from._internal_counter());
1966       break;
1967     }
1968     case kTracepoint: {
1969       _this->_internal_mutable_tracepoint()->::perfetto::protos::PerfEvents_Tracepoint::MergeFrom(
1970           from._internal_tracepoint());
1971       break;
1972     }
1973     case kRawEvent: {
1974       _this->_internal_mutable_raw_event()->::perfetto::protos::PerfEvents_RawEvent::MergeFrom(
1975           from._internal_raw_event());
1976       break;
1977     }
1978     case EVENT_NOT_SET: {
1979       break;
1980     }
1981   }
1982   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1983 }
1984 
CopyFrom(const FollowerEvent & from)1985 void FollowerEvent::CopyFrom(const FollowerEvent& from) {
1986 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.FollowerEvent)
1987   if (&from == this) return;
1988   Clear();
1989   MergeFrom(from);
1990 }
1991 
IsInitialized() const1992 bool FollowerEvent::IsInitialized() const {
1993   return true;
1994 }
1995 
InternalSwap(FollowerEvent * other)1996 void FollowerEvent::InternalSwap(FollowerEvent* other) {
1997   using std::swap;
1998   auto* lhs_arena = GetArenaForAllocation();
1999   auto* rhs_arena = other->GetArenaForAllocation();
2000   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2001   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2002   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
2003       &_impl_.name_, lhs_arena,
2004       &other->_impl_.name_, rhs_arena
2005   );
2006   swap(_impl_.event_, other->_impl_.event_);
2007   swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]);
2008 }
2009 
GetTypeName() const2010 std::string FollowerEvent::GetTypeName() const {
2011   return "perfetto.protos.FollowerEvent";
2012 }
2013 
2014 
2015 // @@protoc_insertion_point(namespace_scope)
2016 }  // namespace protos
2017 }  // namespace perfetto
2018 PROTOBUF_NAMESPACE_OPEN
2019 template<> PROTOBUF_NOINLINE ::perfetto::protos::PerfEvents_Timebase*
CreateMaybeMessage(Arena * arena)2020 Arena::CreateMaybeMessage< ::perfetto::protos::PerfEvents_Timebase >(Arena* arena) {
2021   return Arena::CreateMessageInternal< ::perfetto::protos::PerfEvents_Timebase >(arena);
2022 }
2023 template<> PROTOBUF_NOINLINE ::perfetto::protos::PerfEvents_Tracepoint*
CreateMaybeMessage(Arena * arena)2024 Arena::CreateMaybeMessage< ::perfetto::protos::PerfEvents_Tracepoint >(Arena* arena) {
2025   return Arena::CreateMessageInternal< ::perfetto::protos::PerfEvents_Tracepoint >(arena);
2026 }
2027 template<> PROTOBUF_NOINLINE ::perfetto::protos::PerfEvents_RawEvent*
CreateMaybeMessage(Arena * arena)2028 Arena::CreateMaybeMessage< ::perfetto::protos::PerfEvents_RawEvent >(Arena* arena) {
2029   return Arena::CreateMessageInternal< ::perfetto::protos::PerfEvents_RawEvent >(arena);
2030 }
2031 template<> PROTOBUF_NOINLINE ::perfetto::protos::PerfEvents*
CreateMaybeMessage(Arena * arena)2032 Arena::CreateMaybeMessage< ::perfetto::protos::PerfEvents >(Arena* arena) {
2033   return Arena::CreateMessageInternal< ::perfetto::protos::PerfEvents >(arena);
2034 }
2035 template<> PROTOBUF_NOINLINE ::perfetto::protos::FollowerEvent*
CreateMaybeMessage(Arena * arena)2036 Arena::CreateMaybeMessage< ::perfetto::protos::FollowerEvent >(Arena* arena) {
2037   return Arena::CreateMessageInternal< ::perfetto::protos::FollowerEvent >(arena);
2038 }
2039 PROTOBUF_NAMESPACE_CLOSE
2040 
2041 // @@protoc_insertion_point(global_scope)
2042 #include <google/protobuf/port_undef.inc>
2043