1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/config/android/android_input_event_config.proto
3 
4 #include "protos/perfetto/config/android/android_input_event_config.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 {
AndroidInputEventConfig_TraceRule(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR AndroidInputEventConfig_TraceRule::AndroidInputEventConfig_TraceRule(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.match_all_packages_)*/{}
28   , /*decltype(_impl_.match_any_packages_)*/{}
29   , /*decltype(_impl_.trace_level_)*/0
30   , /*decltype(_impl_.match_secure_)*/false
31   , /*decltype(_impl_.match_ime_connection_active_)*/false} {}
32 struct AndroidInputEventConfig_TraceRuleDefaultTypeInternal {
AndroidInputEventConfig_TraceRuleDefaultTypeInternalperfetto::protos::AndroidInputEventConfig_TraceRuleDefaultTypeInternal33   PROTOBUF_CONSTEXPR AndroidInputEventConfig_TraceRuleDefaultTypeInternal()
34       : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidInputEventConfig_TraceRuleDefaultTypeInternalperfetto::protos::AndroidInputEventConfig_TraceRuleDefaultTypeInternal35   ~AndroidInputEventConfig_TraceRuleDefaultTypeInternal() {}
36   union {  // NOLINT(misc-non-private-member-variables-in-classes)
37     AndroidInputEventConfig_TraceRule _instance;
38   };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidInputEventConfig_TraceRuleDefaultTypeInternal _AndroidInputEventConfig_TraceRule_default_instance_;
AndroidInputEventConfig(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR AndroidInputEventConfig::AndroidInputEventConfig(
42     ::_pbi::ConstantInitialized): _impl_{
43     /*decltype(_impl_._has_bits_)*/{}
44   , /*decltype(_impl_._cached_size_)*/{}
45   , /*decltype(_impl_.rules_)*/{}
46   , /*decltype(_impl_.mode_)*/0
47   , /*decltype(_impl_.trace_dispatcher_input_events_)*/false
48   , /*decltype(_impl_.trace_dispatcher_window_dispatch_)*/false} {}
49 struct AndroidInputEventConfigDefaultTypeInternal {
AndroidInputEventConfigDefaultTypeInternalperfetto::protos::AndroidInputEventConfigDefaultTypeInternal50   PROTOBUF_CONSTEXPR AndroidInputEventConfigDefaultTypeInternal()
51       : _instance(::_pbi::ConstantInitialized{}) {}
~AndroidInputEventConfigDefaultTypeInternalperfetto::protos::AndroidInputEventConfigDefaultTypeInternal52   ~AndroidInputEventConfigDefaultTypeInternal() {}
53   union {  // NOLINT(misc-non-private-member-variables-in-classes)
54     AndroidInputEventConfig _instance;
55   };
56 };
57 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AndroidInputEventConfigDefaultTypeInternal _AndroidInputEventConfig_default_instance_;
58 }  // namespace protos
59 }  // namespace perfetto
60 namespace perfetto {
61 namespace protos {
AndroidInputEventConfig_TraceMode_IsValid(int value)62 bool AndroidInputEventConfig_TraceMode_IsValid(int value) {
63   switch (value) {
64     case 0:
65     case 1:
66       return true;
67     default:
68       return false;
69   }
70 }
71 
72 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AndroidInputEventConfig_TraceMode_strings[2] = {};
73 
74 static const char AndroidInputEventConfig_TraceMode_names[] =
75   "TRACE_MODE_TRACE_ALL"
76   "TRACE_MODE_USE_RULES";
77 
78 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AndroidInputEventConfig_TraceMode_entries[] = {
79   { {AndroidInputEventConfig_TraceMode_names + 0, 20}, 0 },
80   { {AndroidInputEventConfig_TraceMode_names + 20, 20}, 1 },
81 };
82 
83 static const int AndroidInputEventConfig_TraceMode_entries_by_number[] = {
84   0, // 0 -> TRACE_MODE_TRACE_ALL
85   1, // 1 -> TRACE_MODE_USE_RULES
86 };
87 
AndroidInputEventConfig_TraceMode_Name(AndroidInputEventConfig_TraceMode value)88 const std::string& AndroidInputEventConfig_TraceMode_Name(
89     AndroidInputEventConfig_TraceMode value) {
90   static const bool dummy =
91       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
92           AndroidInputEventConfig_TraceMode_entries,
93           AndroidInputEventConfig_TraceMode_entries_by_number,
94           2, AndroidInputEventConfig_TraceMode_strings);
95   (void) dummy;
96   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
97       AndroidInputEventConfig_TraceMode_entries,
98       AndroidInputEventConfig_TraceMode_entries_by_number,
99       2, value);
100   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
101                      AndroidInputEventConfig_TraceMode_strings[idx].get();
102 }
AndroidInputEventConfig_TraceMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,AndroidInputEventConfig_TraceMode * value)103 bool AndroidInputEventConfig_TraceMode_Parse(
104     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AndroidInputEventConfig_TraceMode* value) {
105   int int_value;
106   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
107       AndroidInputEventConfig_TraceMode_entries, 2, name, &int_value);
108   if (success) {
109     *value = static_cast<AndroidInputEventConfig_TraceMode>(int_value);
110   }
111   return success;
112 }
113 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
114 constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig::TRACE_MODE_TRACE_ALL;
115 constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig::TRACE_MODE_USE_RULES;
116 constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig::TraceMode_MIN;
117 constexpr AndroidInputEventConfig_TraceMode AndroidInputEventConfig::TraceMode_MAX;
118 constexpr int AndroidInputEventConfig::TraceMode_ARRAYSIZE;
119 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
AndroidInputEventConfig_TraceLevel_IsValid(int value)120 bool AndroidInputEventConfig_TraceLevel_IsValid(int value) {
121   switch (value) {
122     case 0:
123     case 1:
124     case 2:
125       return true;
126     default:
127       return false;
128   }
129 }
130 
131 static ::PROTOBUF_NAMESPACE_ID::internal::ExplicitlyConstructed<std::string> AndroidInputEventConfig_TraceLevel_strings[3] = {};
132 
133 static const char AndroidInputEventConfig_TraceLevel_names[] =
134   "TRACE_LEVEL_COMPLETE"
135   "TRACE_LEVEL_NONE"
136   "TRACE_LEVEL_REDACTED";
137 
138 static const ::PROTOBUF_NAMESPACE_ID::internal::EnumEntry AndroidInputEventConfig_TraceLevel_entries[] = {
139   { {AndroidInputEventConfig_TraceLevel_names + 0, 20}, 2 },
140   { {AndroidInputEventConfig_TraceLevel_names + 20, 16}, 0 },
141   { {AndroidInputEventConfig_TraceLevel_names + 36, 20}, 1 },
142 };
143 
144 static const int AndroidInputEventConfig_TraceLevel_entries_by_number[] = {
145   1, // 0 -> TRACE_LEVEL_NONE
146   2, // 1 -> TRACE_LEVEL_REDACTED
147   0, // 2 -> TRACE_LEVEL_COMPLETE
148 };
149 
AndroidInputEventConfig_TraceLevel_Name(AndroidInputEventConfig_TraceLevel value)150 const std::string& AndroidInputEventConfig_TraceLevel_Name(
151     AndroidInputEventConfig_TraceLevel value) {
152   static const bool dummy =
153       ::PROTOBUF_NAMESPACE_ID::internal::InitializeEnumStrings(
154           AndroidInputEventConfig_TraceLevel_entries,
155           AndroidInputEventConfig_TraceLevel_entries_by_number,
156           3, AndroidInputEventConfig_TraceLevel_strings);
157   (void) dummy;
158   int idx = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumName(
159       AndroidInputEventConfig_TraceLevel_entries,
160       AndroidInputEventConfig_TraceLevel_entries_by_number,
161       3, value);
162   return idx == -1 ? ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString() :
163                      AndroidInputEventConfig_TraceLevel_strings[idx].get();
164 }
AndroidInputEventConfig_TraceLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,AndroidInputEventConfig_TraceLevel * value)165 bool AndroidInputEventConfig_TraceLevel_Parse(
166     ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AndroidInputEventConfig_TraceLevel* value) {
167   int int_value;
168   bool success = ::PROTOBUF_NAMESPACE_ID::internal::LookUpEnumValue(
169       AndroidInputEventConfig_TraceLevel_entries, 3, name, &int_value);
170   if (success) {
171     *value = static_cast<AndroidInputEventConfig_TraceLevel>(int_value);
172   }
173   return success;
174 }
175 #if (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
176 constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig::TRACE_LEVEL_NONE;
177 constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig::TRACE_LEVEL_REDACTED;
178 constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig::TRACE_LEVEL_COMPLETE;
179 constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig::TraceLevel_MIN;
180 constexpr AndroidInputEventConfig_TraceLevel AndroidInputEventConfig::TraceLevel_MAX;
181 constexpr int AndroidInputEventConfig::TraceLevel_ARRAYSIZE;
182 #endif  // (__cplusplus < 201703) && (!defined(_MSC_VER) || (_MSC_VER >= 1900 && _MSC_VER < 1912))
183 
184 // ===================================================================
185 
186 class AndroidInputEventConfig_TraceRule::_Internal {
187  public:
188   using HasBits = decltype(std::declval<AndroidInputEventConfig_TraceRule>()._impl_._has_bits_);
set_has_trace_level(HasBits * has_bits)189   static void set_has_trace_level(HasBits* has_bits) {
190     (*has_bits)[0] |= 1u;
191   }
set_has_match_secure(HasBits * has_bits)192   static void set_has_match_secure(HasBits* has_bits) {
193     (*has_bits)[0] |= 2u;
194   }
set_has_match_ime_connection_active(HasBits * has_bits)195   static void set_has_match_ime_connection_active(HasBits* has_bits) {
196     (*has_bits)[0] |= 4u;
197   }
198 };
199 
AndroidInputEventConfig_TraceRule(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)200 AndroidInputEventConfig_TraceRule::AndroidInputEventConfig_TraceRule(::PROTOBUF_NAMESPACE_ID::Arena* arena,
201                          bool is_message_owned)
202   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
203   SharedCtor(arena, is_message_owned);
204   // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidInputEventConfig.TraceRule)
205 }
AndroidInputEventConfig_TraceRule(const AndroidInputEventConfig_TraceRule & from)206 AndroidInputEventConfig_TraceRule::AndroidInputEventConfig_TraceRule(const AndroidInputEventConfig_TraceRule& from)
207   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
208   AndroidInputEventConfig_TraceRule* const _this = this; (void)_this;
209   new (&_impl_) Impl_{
210       decltype(_impl_._has_bits_){from._impl_._has_bits_}
211     , /*decltype(_impl_._cached_size_)*/{}
212     , decltype(_impl_.match_all_packages_){from._impl_.match_all_packages_}
213     , decltype(_impl_.match_any_packages_){from._impl_.match_any_packages_}
214     , decltype(_impl_.trace_level_){}
215     , decltype(_impl_.match_secure_){}
216     , decltype(_impl_.match_ime_connection_active_){}};
217 
218   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
219   ::memcpy(&_impl_.trace_level_, &from._impl_.trace_level_,
220     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.match_ime_connection_active_) -
221     reinterpret_cast<char*>(&_impl_.trace_level_)) + sizeof(_impl_.match_ime_connection_active_));
222   // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidInputEventConfig.TraceRule)
223 }
224 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)225 inline void AndroidInputEventConfig_TraceRule::SharedCtor(
226     ::_pb::Arena* arena, bool is_message_owned) {
227   (void)arena;
228   (void)is_message_owned;
229   new (&_impl_) Impl_{
230       decltype(_impl_._has_bits_){}
231     , /*decltype(_impl_._cached_size_)*/{}
232     , decltype(_impl_.match_all_packages_){arena}
233     , decltype(_impl_.match_any_packages_){arena}
234     , decltype(_impl_.trace_level_){0}
235     , decltype(_impl_.match_secure_){false}
236     , decltype(_impl_.match_ime_connection_active_){false}
237   };
238 }
239 
~AndroidInputEventConfig_TraceRule()240 AndroidInputEventConfig_TraceRule::~AndroidInputEventConfig_TraceRule() {
241   // @@protoc_insertion_point(destructor:perfetto.protos.AndroidInputEventConfig.TraceRule)
242   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
243   (void)arena;
244     return;
245   }
246   SharedDtor();
247 }
248 
SharedDtor()249 inline void AndroidInputEventConfig_TraceRule::SharedDtor() {
250   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
251   _impl_.match_all_packages_.~RepeatedPtrField();
252   _impl_.match_any_packages_.~RepeatedPtrField();
253 }
254 
SetCachedSize(int size) const255 void AndroidInputEventConfig_TraceRule::SetCachedSize(int size) const {
256   _impl_._cached_size_.Set(size);
257 }
258 
Clear()259 void AndroidInputEventConfig_TraceRule::Clear() {
260 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidInputEventConfig.TraceRule)
261   ::uint32_t cached_has_bits = 0;
262   // Prevent compiler warnings about cached_has_bits being unused
263   (void) cached_has_bits;
264 
265   _impl_.match_all_packages_.Clear();
266   _impl_.match_any_packages_.Clear();
267   cached_has_bits = _impl_._has_bits_[0];
268   if (cached_has_bits & 0x00000007u) {
269     ::memset(&_impl_.trace_level_, 0, static_cast<size_t>(
270         reinterpret_cast<char*>(&_impl_.match_ime_connection_active_) -
271         reinterpret_cast<char*>(&_impl_.trace_level_)) + sizeof(_impl_.match_ime_connection_active_));
272   }
273   _impl_._has_bits_.Clear();
274   _internal_metadata_.Clear<std::string>();
275 }
276 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)277 const char* AndroidInputEventConfig_TraceRule::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
278 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
279   _Internal::HasBits has_bits{};
280   while (!ctx->Done(&ptr)) {
281     ::uint32_t tag;
282     ptr = ::_pbi::ReadTag(ptr, &tag);
283     switch (tag >> 3) {
284       // optional .perfetto.protos.AndroidInputEventConfig.TraceLevel trace_level = 1;
285       case 1:
286         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
287           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
288           CHK_(ptr);
289           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::AndroidInputEventConfig_TraceLevel_IsValid(val))) {
290             _internal_set_trace_level(static_cast<::perfetto::protos::AndroidInputEventConfig_TraceLevel>(val));
291           } else {
292             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
293           }
294         } else {
295           goto handle_unusual;
296         }
297         continue;
298       // repeated string match_all_packages = 2;
299       case 2:
300         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
301           ptr -= 1;
302           do {
303             ptr += 1;
304             auto str = _internal_add_match_all_packages();
305             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
306             CHK_(ptr);
307             if (!ctx->DataAvailable(ptr)) break;
308           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
309         } else {
310           goto handle_unusual;
311         }
312         continue;
313       // repeated string match_any_packages = 3;
314       case 3:
315         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 26)) {
316           ptr -= 1;
317           do {
318             ptr += 1;
319             auto str = _internal_add_match_any_packages();
320             ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
321             CHK_(ptr);
322             if (!ctx->DataAvailable(ptr)) break;
323           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr));
324         } else {
325           goto handle_unusual;
326         }
327         continue;
328       // optional bool match_secure = 4;
329       case 4:
330         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
331           _Internal::set_has_match_secure(&has_bits);
332           _impl_.match_secure_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
333           CHK_(ptr);
334         } else {
335           goto handle_unusual;
336         }
337         continue;
338       // optional bool match_ime_connection_active = 5;
339       case 5:
340         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
341           _Internal::set_has_match_ime_connection_active(&has_bits);
342           _impl_.match_ime_connection_active_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
343           CHK_(ptr);
344         } else {
345           goto handle_unusual;
346         }
347         continue;
348       default:
349         goto handle_unusual;
350     }  // switch
351   handle_unusual:
352     if ((tag == 0) || ((tag & 7) == 4)) {
353       CHK_(ptr);
354       ctx->SetLastTag(tag);
355       goto message_done;
356     }
357     ptr = UnknownFieldParse(
358         tag,
359         _internal_metadata_.mutable_unknown_fields<std::string>(),
360         ptr, ctx);
361     CHK_(ptr != nullptr);
362   }  // while
363 message_done:
364   _impl_._has_bits_.Or(has_bits);
365   return ptr;
366 failure:
367   ptr = nullptr;
368   goto message_done;
369 #undef CHK_
370 }
371 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const372 ::uint8_t* AndroidInputEventConfig_TraceRule::_InternalSerialize(
373     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
374   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidInputEventConfig.TraceRule)
375   ::uint32_t cached_has_bits = 0;
376   (void) cached_has_bits;
377 
378   cached_has_bits = _impl_._has_bits_[0];
379   // optional .perfetto.protos.AndroidInputEventConfig.TraceLevel trace_level = 1;
380   if (cached_has_bits & 0x00000001u) {
381     target = stream->EnsureSpace(target);
382     target = ::_pbi::WireFormatLite::WriteEnumToArray(
383       1, this->_internal_trace_level(), target);
384   }
385 
386   // repeated string match_all_packages = 2;
387   for (int i = 0, n = this->_internal_match_all_packages_size(); i < n; i++) {
388     const auto& s = this->_internal_match_all_packages(i);
389     target = stream->WriteString(2, s, target);
390   }
391 
392   // repeated string match_any_packages = 3;
393   for (int i = 0, n = this->_internal_match_any_packages_size(); i < n; i++) {
394     const auto& s = this->_internal_match_any_packages(i);
395     target = stream->WriteString(3, s, target);
396   }
397 
398   // optional bool match_secure = 4;
399   if (cached_has_bits & 0x00000002u) {
400     target = stream->EnsureSpace(target);
401     target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_match_secure(), target);
402   }
403 
404   // optional bool match_ime_connection_active = 5;
405   if (cached_has_bits & 0x00000004u) {
406     target = stream->EnsureSpace(target);
407     target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_match_ime_connection_active(), target);
408   }
409 
410   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
411     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
412         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
413   }
414   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidInputEventConfig.TraceRule)
415   return target;
416 }
417 
ByteSizeLong() const418 size_t AndroidInputEventConfig_TraceRule::ByteSizeLong() const {
419 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidInputEventConfig.TraceRule)
420   size_t total_size = 0;
421 
422   ::uint32_t cached_has_bits = 0;
423   // Prevent compiler warnings about cached_has_bits being unused
424   (void) cached_has_bits;
425 
426   // repeated string match_all_packages = 2;
427   total_size += 1 *
428       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.match_all_packages_.size());
429   for (int i = 0, n = _impl_.match_all_packages_.size(); i < n; i++) {
430     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
431       _impl_.match_all_packages_.Get(i));
432   }
433 
434   // repeated string match_any_packages = 3;
435   total_size += 1 *
436       ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(_impl_.match_any_packages_.size());
437   for (int i = 0, n = _impl_.match_any_packages_.size(); i < n; i++) {
438     total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
439       _impl_.match_any_packages_.Get(i));
440   }
441 
442   cached_has_bits = _impl_._has_bits_[0];
443   if (cached_has_bits & 0x00000007u) {
444     // optional .perfetto.protos.AndroidInputEventConfig.TraceLevel trace_level = 1;
445     if (cached_has_bits & 0x00000001u) {
446       total_size += 1 +
447         ::_pbi::WireFormatLite::EnumSize(this->_internal_trace_level());
448     }
449 
450     // optional bool match_secure = 4;
451     if (cached_has_bits & 0x00000002u) {
452       total_size += 1 + 1;
453     }
454 
455     // optional bool match_ime_connection_active = 5;
456     if (cached_has_bits & 0x00000004u) {
457       total_size += 1 + 1;
458     }
459 
460   }
461   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
462     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
463   }
464   int cached_size = ::_pbi::ToCachedSize(total_size);
465   SetCachedSize(cached_size);
466   return total_size;
467 }
468 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)469 void AndroidInputEventConfig_TraceRule::CheckTypeAndMergeFrom(
470     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
471   MergeFrom(*::_pbi::DownCast<const AndroidInputEventConfig_TraceRule*>(
472       &from));
473 }
474 
MergeFrom(const AndroidInputEventConfig_TraceRule & from)475 void AndroidInputEventConfig_TraceRule::MergeFrom(const AndroidInputEventConfig_TraceRule& from) {
476   AndroidInputEventConfig_TraceRule* const _this = this;
477   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidInputEventConfig.TraceRule)
478   GOOGLE_DCHECK_NE(&from, _this);
479   ::uint32_t cached_has_bits = 0;
480   (void) cached_has_bits;
481 
482   _this->_impl_.match_all_packages_.MergeFrom(from._impl_.match_all_packages_);
483   _this->_impl_.match_any_packages_.MergeFrom(from._impl_.match_any_packages_);
484   cached_has_bits = from._impl_._has_bits_[0];
485   if (cached_has_bits & 0x00000007u) {
486     if (cached_has_bits & 0x00000001u) {
487       _this->_impl_.trace_level_ = from._impl_.trace_level_;
488     }
489     if (cached_has_bits & 0x00000002u) {
490       _this->_impl_.match_secure_ = from._impl_.match_secure_;
491     }
492     if (cached_has_bits & 0x00000004u) {
493       _this->_impl_.match_ime_connection_active_ = from._impl_.match_ime_connection_active_;
494     }
495     _this->_impl_._has_bits_[0] |= cached_has_bits;
496   }
497   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
498 }
499 
CopyFrom(const AndroidInputEventConfig_TraceRule & from)500 void AndroidInputEventConfig_TraceRule::CopyFrom(const AndroidInputEventConfig_TraceRule& from) {
501 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidInputEventConfig.TraceRule)
502   if (&from == this) return;
503   Clear();
504   MergeFrom(from);
505 }
506 
IsInitialized() const507 bool AndroidInputEventConfig_TraceRule::IsInitialized() const {
508   return true;
509 }
510 
InternalSwap(AndroidInputEventConfig_TraceRule * other)511 void AndroidInputEventConfig_TraceRule::InternalSwap(AndroidInputEventConfig_TraceRule* other) {
512   using std::swap;
513   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
514   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
515   _impl_.match_all_packages_.InternalSwap(&other->_impl_.match_all_packages_);
516   _impl_.match_any_packages_.InternalSwap(&other->_impl_.match_any_packages_);
517   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
518       PROTOBUF_FIELD_OFFSET(AndroidInputEventConfig_TraceRule, _impl_.match_ime_connection_active_)
519       + sizeof(AndroidInputEventConfig_TraceRule::_impl_.match_ime_connection_active_)  // NOLINT
520       - PROTOBUF_FIELD_OFFSET(AndroidInputEventConfig_TraceRule, _impl_.trace_level_)>(
521           reinterpret_cast<char*>(&_impl_.trace_level_),
522           reinterpret_cast<char*>(&other->_impl_.trace_level_));
523 }
524 
GetTypeName() const525 std::string AndroidInputEventConfig_TraceRule::GetTypeName() const {
526   return "perfetto.protos.AndroidInputEventConfig.TraceRule";
527 }
528 
529 
530 // ===================================================================
531 
532 class AndroidInputEventConfig::_Internal {
533  public:
534   using HasBits = decltype(std::declval<AndroidInputEventConfig>()._impl_._has_bits_);
set_has_mode(HasBits * has_bits)535   static void set_has_mode(HasBits* has_bits) {
536     (*has_bits)[0] |= 1u;
537   }
set_has_trace_dispatcher_input_events(HasBits * has_bits)538   static void set_has_trace_dispatcher_input_events(HasBits* has_bits) {
539     (*has_bits)[0] |= 2u;
540   }
set_has_trace_dispatcher_window_dispatch(HasBits * has_bits)541   static void set_has_trace_dispatcher_window_dispatch(HasBits* has_bits) {
542     (*has_bits)[0] |= 4u;
543   }
544 };
545 
AndroidInputEventConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)546 AndroidInputEventConfig::AndroidInputEventConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
547                          bool is_message_owned)
548   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
549   SharedCtor(arena, is_message_owned);
550   // @@protoc_insertion_point(arena_constructor:perfetto.protos.AndroidInputEventConfig)
551 }
AndroidInputEventConfig(const AndroidInputEventConfig & from)552 AndroidInputEventConfig::AndroidInputEventConfig(const AndroidInputEventConfig& from)
553   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
554   AndroidInputEventConfig* const _this = this; (void)_this;
555   new (&_impl_) Impl_{
556       decltype(_impl_._has_bits_){from._impl_._has_bits_}
557     , /*decltype(_impl_._cached_size_)*/{}
558     , decltype(_impl_.rules_){from._impl_.rules_}
559     , decltype(_impl_.mode_){}
560     , decltype(_impl_.trace_dispatcher_input_events_){}
561     , decltype(_impl_.trace_dispatcher_window_dispatch_){}};
562 
563   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
564   ::memcpy(&_impl_.mode_, &from._impl_.mode_,
565     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.trace_dispatcher_window_dispatch_) -
566     reinterpret_cast<char*>(&_impl_.mode_)) + sizeof(_impl_.trace_dispatcher_window_dispatch_));
567   // @@protoc_insertion_point(copy_constructor:perfetto.protos.AndroidInputEventConfig)
568 }
569 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)570 inline void AndroidInputEventConfig::SharedCtor(
571     ::_pb::Arena* arena, bool is_message_owned) {
572   (void)arena;
573   (void)is_message_owned;
574   new (&_impl_) Impl_{
575       decltype(_impl_._has_bits_){}
576     , /*decltype(_impl_._cached_size_)*/{}
577     , decltype(_impl_.rules_){arena}
578     , decltype(_impl_.mode_){0}
579     , decltype(_impl_.trace_dispatcher_input_events_){false}
580     , decltype(_impl_.trace_dispatcher_window_dispatch_){false}
581   };
582 }
583 
~AndroidInputEventConfig()584 AndroidInputEventConfig::~AndroidInputEventConfig() {
585   // @@protoc_insertion_point(destructor:perfetto.protos.AndroidInputEventConfig)
586   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
587   (void)arena;
588     return;
589   }
590   SharedDtor();
591 }
592 
SharedDtor()593 inline void AndroidInputEventConfig::SharedDtor() {
594   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
595   _impl_.rules_.~RepeatedPtrField();
596 }
597 
SetCachedSize(int size) const598 void AndroidInputEventConfig::SetCachedSize(int size) const {
599   _impl_._cached_size_.Set(size);
600 }
601 
Clear()602 void AndroidInputEventConfig::Clear() {
603 // @@protoc_insertion_point(message_clear_start:perfetto.protos.AndroidInputEventConfig)
604   ::uint32_t cached_has_bits = 0;
605   // Prevent compiler warnings about cached_has_bits being unused
606   (void) cached_has_bits;
607 
608   _impl_.rules_.Clear();
609   cached_has_bits = _impl_._has_bits_[0];
610   if (cached_has_bits & 0x00000007u) {
611     ::memset(&_impl_.mode_, 0, static_cast<size_t>(
612         reinterpret_cast<char*>(&_impl_.trace_dispatcher_window_dispatch_) -
613         reinterpret_cast<char*>(&_impl_.mode_)) + sizeof(_impl_.trace_dispatcher_window_dispatch_));
614   }
615   _impl_._has_bits_.Clear();
616   _internal_metadata_.Clear<std::string>();
617 }
618 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)619 const char* AndroidInputEventConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
620 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
621   _Internal::HasBits has_bits{};
622   while (!ctx->Done(&ptr)) {
623     ::uint32_t tag;
624     ptr = ::_pbi::ReadTag(ptr, &tag);
625     switch (tag >> 3) {
626       // optional .perfetto.protos.AndroidInputEventConfig.TraceMode mode = 1;
627       case 1:
628         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
629           ::uint64_t val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
630           CHK_(ptr);
631           if (PROTOBUF_PREDICT_TRUE(::perfetto::protos::AndroidInputEventConfig_TraceMode_IsValid(val))) {
632             _internal_set_mode(static_cast<::perfetto::protos::AndroidInputEventConfig_TraceMode>(val));
633           } else {
634             ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(1, val, mutable_unknown_fields());
635           }
636         } else {
637           goto handle_unusual;
638         }
639         continue;
640       // repeated .perfetto.protos.AndroidInputEventConfig.TraceRule rules = 2;
641       case 2:
642         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 18)) {
643           ptr -= 1;
644           do {
645             ptr += 1;
646             ptr = ctx->ParseMessage(_internal_add_rules(), ptr);
647             CHK_(ptr);
648             if (!ctx->DataAvailable(ptr)) break;
649           } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<18>(ptr));
650         } else {
651           goto handle_unusual;
652         }
653         continue;
654       // optional bool trace_dispatcher_input_events = 3;
655       case 3:
656         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
657           _Internal::set_has_trace_dispatcher_input_events(&has_bits);
658           _impl_.trace_dispatcher_input_events_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
659           CHK_(ptr);
660         } else {
661           goto handle_unusual;
662         }
663         continue;
664       // optional bool trace_dispatcher_window_dispatch = 4;
665       case 4:
666         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
667           _Internal::set_has_trace_dispatcher_window_dispatch(&has_bits);
668           _impl_.trace_dispatcher_window_dispatch_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
669           CHK_(ptr);
670         } else {
671           goto handle_unusual;
672         }
673         continue;
674       default:
675         goto handle_unusual;
676     }  // switch
677   handle_unusual:
678     if ((tag == 0) || ((tag & 7) == 4)) {
679       CHK_(ptr);
680       ctx->SetLastTag(tag);
681       goto message_done;
682     }
683     ptr = UnknownFieldParse(
684         tag,
685         _internal_metadata_.mutable_unknown_fields<std::string>(),
686         ptr, ctx);
687     CHK_(ptr != nullptr);
688   }  // while
689 message_done:
690   _impl_._has_bits_.Or(has_bits);
691   return ptr;
692 failure:
693   ptr = nullptr;
694   goto message_done;
695 #undef CHK_
696 }
697 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const698 ::uint8_t* AndroidInputEventConfig::_InternalSerialize(
699     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
700   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.AndroidInputEventConfig)
701   ::uint32_t cached_has_bits = 0;
702   (void) cached_has_bits;
703 
704   cached_has_bits = _impl_._has_bits_[0];
705   // optional .perfetto.protos.AndroidInputEventConfig.TraceMode mode = 1;
706   if (cached_has_bits & 0x00000001u) {
707     target = stream->EnsureSpace(target);
708     target = ::_pbi::WireFormatLite::WriteEnumToArray(
709       1, this->_internal_mode(), target);
710   }
711 
712   // repeated .perfetto.protos.AndroidInputEventConfig.TraceRule rules = 2;
713   for (unsigned i = 0,
714       n = static_cast<unsigned>(this->_internal_rules_size()); i < n; i++) {
715     const auto& repfield = this->_internal_rules(i);
716     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
717         InternalWriteMessage(2, repfield, repfield.GetCachedSize(), target, stream);
718   }
719 
720   // optional bool trace_dispatcher_input_events = 3;
721   if (cached_has_bits & 0x00000002u) {
722     target = stream->EnsureSpace(target);
723     target = ::_pbi::WireFormatLite::WriteBoolToArray(3, this->_internal_trace_dispatcher_input_events(), target);
724   }
725 
726   // optional bool trace_dispatcher_window_dispatch = 4;
727   if (cached_has_bits & 0x00000004u) {
728     target = stream->EnsureSpace(target);
729     target = ::_pbi::WireFormatLite::WriteBoolToArray(4, this->_internal_trace_dispatcher_window_dispatch(), target);
730   }
731 
732   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
733     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
734         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
735   }
736   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.AndroidInputEventConfig)
737   return target;
738 }
739 
ByteSizeLong() const740 size_t AndroidInputEventConfig::ByteSizeLong() const {
741 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.AndroidInputEventConfig)
742   size_t total_size = 0;
743 
744   ::uint32_t cached_has_bits = 0;
745   // Prevent compiler warnings about cached_has_bits being unused
746   (void) cached_has_bits;
747 
748   // repeated .perfetto.protos.AndroidInputEventConfig.TraceRule rules = 2;
749   total_size += 1UL * this->_internal_rules_size();
750   for (const auto& msg : this->_impl_.rules_) {
751     total_size +=
752       ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
753   }
754 
755   cached_has_bits = _impl_._has_bits_[0];
756   if (cached_has_bits & 0x00000007u) {
757     // optional .perfetto.protos.AndroidInputEventConfig.TraceMode mode = 1;
758     if (cached_has_bits & 0x00000001u) {
759       total_size += 1 +
760         ::_pbi::WireFormatLite::EnumSize(this->_internal_mode());
761     }
762 
763     // optional bool trace_dispatcher_input_events = 3;
764     if (cached_has_bits & 0x00000002u) {
765       total_size += 1 + 1;
766     }
767 
768     // optional bool trace_dispatcher_window_dispatch = 4;
769     if (cached_has_bits & 0x00000004u) {
770       total_size += 1 + 1;
771     }
772 
773   }
774   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
775     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
776   }
777   int cached_size = ::_pbi::ToCachedSize(total_size);
778   SetCachedSize(cached_size);
779   return total_size;
780 }
781 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)782 void AndroidInputEventConfig::CheckTypeAndMergeFrom(
783     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
784   MergeFrom(*::_pbi::DownCast<const AndroidInputEventConfig*>(
785       &from));
786 }
787 
MergeFrom(const AndroidInputEventConfig & from)788 void AndroidInputEventConfig::MergeFrom(const AndroidInputEventConfig& from) {
789   AndroidInputEventConfig* const _this = this;
790   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.AndroidInputEventConfig)
791   GOOGLE_DCHECK_NE(&from, _this);
792   ::uint32_t cached_has_bits = 0;
793   (void) cached_has_bits;
794 
795   _this->_impl_.rules_.MergeFrom(from._impl_.rules_);
796   cached_has_bits = from._impl_._has_bits_[0];
797   if (cached_has_bits & 0x00000007u) {
798     if (cached_has_bits & 0x00000001u) {
799       _this->_impl_.mode_ = from._impl_.mode_;
800     }
801     if (cached_has_bits & 0x00000002u) {
802       _this->_impl_.trace_dispatcher_input_events_ = from._impl_.trace_dispatcher_input_events_;
803     }
804     if (cached_has_bits & 0x00000004u) {
805       _this->_impl_.trace_dispatcher_window_dispatch_ = from._impl_.trace_dispatcher_window_dispatch_;
806     }
807     _this->_impl_._has_bits_[0] |= cached_has_bits;
808   }
809   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
810 }
811 
CopyFrom(const AndroidInputEventConfig & from)812 void AndroidInputEventConfig::CopyFrom(const AndroidInputEventConfig& from) {
813 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.AndroidInputEventConfig)
814   if (&from == this) return;
815   Clear();
816   MergeFrom(from);
817 }
818 
IsInitialized() const819 bool AndroidInputEventConfig::IsInitialized() const {
820   return true;
821 }
822 
InternalSwap(AndroidInputEventConfig * other)823 void AndroidInputEventConfig::InternalSwap(AndroidInputEventConfig* other) {
824   using std::swap;
825   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
826   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
827   _impl_.rules_.InternalSwap(&other->_impl_.rules_);
828   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
829       PROTOBUF_FIELD_OFFSET(AndroidInputEventConfig, _impl_.trace_dispatcher_window_dispatch_)
830       + sizeof(AndroidInputEventConfig::_impl_.trace_dispatcher_window_dispatch_)  // NOLINT
831       - PROTOBUF_FIELD_OFFSET(AndroidInputEventConfig, _impl_.mode_)>(
832           reinterpret_cast<char*>(&_impl_.mode_),
833           reinterpret_cast<char*>(&other->_impl_.mode_));
834 }
835 
GetTypeName() const836 std::string AndroidInputEventConfig::GetTypeName() const {
837   return "perfetto.protos.AndroidInputEventConfig";
838 }
839 
840 
841 // @@protoc_insertion_point(namespace_scope)
842 }  // namespace protos
843 }  // namespace perfetto
844 PROTOBUF_NAMESPACE_OPEN
845 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidInputEventConfig_TraceRule*
CreateMaybeMessage(Arena * arena)846 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidInputEventConfig_TraceRule >(Arena* arena) {
847   return Arena::CreateMessageInternal< ::perfetto::protos::AndroidInputEventConfig_TraceRule >(arena);
848 }
849 template<> PROTOBUF_NOINLINE ::perfetto::protos::AndroidInputEventConfig*
CreateMaybeMessage(Arena * arena)850 Arena::CreateMaybeMessage< ::perfetto::protos::AndroidInputEventConfig >(Arena* arena) {
851   return Arena::CreateMessageInternal< ::perfetto::protos::AndroidInputEventConfig >(arena);
852 }
853 PROTOBUF_NAMESPACE_CLOSE
854 
855 // @@protoc_insertion_point(global_scope)
856 #include <google/protobuf/port_undef.inc>
857