1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/config/test_config.proto
3 
4 #include "protos/perfetto/config/test_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 {
TestConfig_DummyFields(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR TestConfig_DummyFields::TestConfig_DummyFields(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.field_string_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.field_bytes_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.field_uint32_)*/0u
30   , /*decltype(_impl_.field_int32_)*/0
31   , /*decltype(_impl_.field_uint64_)*/::uint64_t{0u}
32   , /*decltype(_impl_.field_int64_)*/::int64_t{0}
33   , /*decltype(_impl_.field_fixed64_)*/::uint64_t{0u}
34   , /*decltype(_impl_.field_sfixed64_)*/::int64_t{0}
35   , /*decltype(_impl_.field_fixed32_)*/0u
36   , /*decltype(_impl_.field_sfixed32_)*/0
37   , /*decltype(_impl_.field_double_)*/0
38   , /*decltype(_impl_.field_sint64_)*/::int64_t{0}
39   , /*decltype(_impl_.field_float_)*/0
40   , /*decltype(_impl_.field_sint32_)*/0} {}
41 struct TestConfig_DummyFieldsDefaultTypeInternal {
TestConfig_DummyFieldsDefaultTypeInternalperfetto::protos::TestConfig_DummyFieldsDefaultTypeInternal42   PROTOBUF_CONSTEXPR TestConfig_DummyFieldsDefaultTypeInternal()
43       : _instance(::_pbi::ConstantInitialized{}) {}
~TestConfig_DummyFieldsDefaultTypeInternalperfetto::protos::TestConfig_DummyFieldsDefaultTypeInternal44   ~TestConfig_DummyFieldsDefaultTypeInternal() {}
45   union {  // NOLINT(misc-non-private-member-variables-in-classes)
46     TestConfig_DummyFields _instance;
47   };
48 };
49 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TestConfig_DummyFieldsDefaultTypeInternal _TestConfig_DummyFields_default_instance_;
TestConfig(::_pbi::ConstantInitialized)50 PROTOBUF_CONSTEXPR TestConfig::TestConfig(
51     ::_pbi::ConstantInitialized): _impl_{
52     /*decltype(_impl_._has_bits_)*/{}
53   , /*decltype(_impl_._cached_size_)*/{}
54   , /*decltype(_impl_.dummy_fields_)*/nullptr
55   , /*decltype(_impl_.message_count_)*/0u
56   , /*decltype(_impl_.max_messages_per_second_)*/0u
57   , /*decltype(_impl_.seed_)*/0u
58   , /*decltype(_impl_.message_size_)*/0u
59   , /*decltype(_impl_.send_batch_on_register_)*/false} {}
60 struct TestConfigDefaultTypeInternal {
TestConfigDefaultTypeInternalperfetto::protos::TestConfigDefaultTypeInternal61   PROTOBUF_CONSTEXPR TestConfigDefaultTypeInternal()
62       : _instance(::_pbi::ConstantInitialized{}) {}
~TestConfigDefaultTypeInternalperfetto::protos::TestConfigDefaultTypeInternal63   ~TestConfigDefaultTypeInternal() {}
64   union {  // NOLINT(misc-non-private-member-variables-in-classes)
65     TestConfig _instance;
66   };
67 };
68 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TestConfigDefaultTypeInternal _TestConfig_default_instance_;
69 }  // namespace protos
70 }  // namespace perfetto
71 namespace perfetto {
72 namespace protos {
73 
74 // ===================================================================
75 
76 class TestConfig_DummyFields::_Internal {
77  public:
78   using HasBits = decltype(std::declval<TestConfig_DummyFields>()._impl_._has_bits_);
set_has_field_uint32(HasBits * has_bits)79   static void set_has_field_uint32(HasBits* has_bits) {
80     (*has_bits)[0] |= 4u;
81   }
set_has_field_int32(HasBits * has_bits)82   static void set_has_field_int32(HasBits* has_bits) {
83     (*has_bits)[0] |= 8u;
84   }
set_has_field_uint64(HasBits * has_bits)85   static void set_has_field_uint64(HasBits* has_bits) {
86     (*has_bits)[0] |= 16u;
87   }
set_has_field_int64(HasBits * has_bits)88   static void set_has_field_int64(HasBits* has_bits) {
89     (*has_bits)[0] |= 32u;
90   }
set_has_field_fixed64(HasBits * has_bits)91   static void set_has_field_fixed64(HasBits* has_bits) {
92     (*has_bits)[0] |= 64u;
93   }
set_has_field_sfixed64(HasBits * has_bits)94   static void set_has_field_sfixed64(HasBits* has_bits) {
95     (*has_bits)[0] |= 128u;
96   }
set_has_field_fixed32(HasBits * has_bits)97   static void set_has_field_fixed32(HasBits* has_bits) {
98     (*has_bits)[0] |= 256u;
99   }
set_has_field_sfixed32(HasBits * has_bits)100   static void set_has_field_sfixed32(HasBits* has_bits) {
101     (*has_bits)[0] |= 512u;
102   }
set_has_field_double(HasBits * has_bits)103   static void set_has_field_double(HasBits* has_bits) {
104     (*has_bits)[0] |= 1024u;
105   }
set_has_field_float(HasBits * has_bits)106   static void set_has_field_float(HasBits* has_bits) {
107     (*has_bits)[0] |= 4096u;
108   }
set_has_field_sint64(HasBits * has_bits)109   static void set_has_field_sint64(HasBits* has_bits) {
110     (*has_bits)[0] |= 2048u;
111   }
set_has_field_sint32(HasBits * has_bits)112   static void set_has_field_sint32(HasBits* has_bits) {
113     (*has_bits)[0] |= 8192u;
114   }
set_has_field_string(HasBits * has_bits)115   static void set_has_field_string(HasBits* has_bits) {
116     (*has_bits)[0] |= 1u;
117   }
set_has_field_bytes(HasBits * has_bits)118   static void set_has_field_bytes(HasBits* has_bits) {
119     (*has_bits)[0] |= 2u;
120   }
121 };
122 
TestConfig_DummyFields(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)123 TestConfig_DummyFields::TestConfig_DummyFields(::PROTOBUF_NAMESPACE_ID::Arena* arena,
124                          bool is_message_owned)
125   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
126   SharedCtor(arena, is_message_owned);
127   // @@protoc_insertion_point(arena_constructor:perfetto.protos.TestConfig.DummyFields)
128 }
TestConfig_DummyFields(const TestConfig_DummyFields & from)129 TestConfig_DummyFields::TestConfig_DummyFields(const TestConfig_DummyFields& from)
130   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
131   TestConfig_DummyFields* const _this = this; (void)_this;
132   new (&_impl_) Impl_{
133       decltype(_impl_._has_bits_){from._impl_._has_bits_}
134     , /*decltype(_impl_._cached_size_)*/{}
135     , decltype(_impl_.field_string_){}
136     , decltype(_impl_.field_bytes_){}
137     , decltype(_impl_.field_uint32_){}
138     , decltype(_impl_.field_int32_){}
139     , decltype(_impl_.field_uint64_){}
140     , decltype(_impl_.field_int64_){}
141     , decltype(_impl_.field_fixed64_){}
142     , decltype(_impl_.field_sfixed64_){}
143     , decltype(_impl_.field_fixed32_){}
144     , decltype(_impl_.field_sfixed32_){}
145     , decltype(_impl_.field_double_){}
146     , decltype(_impl_.field_sint64_){}
147     , decltype(_impl_.field_float_){}
148     , decltype(_impl_.field_sint32_){}};
149 
150   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
151   _impl_.field_string_.InitDefault();
152   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
153     _impl_.field_string_.Set("", GetArenaForAllocation());
154   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
155   if (from._internal_has_field_string()) {
156     _this->_impl_.field_string_.Set(from._internal_field_string(),
157       _this->GetArenaForAllocation());
158   }
159   _impl_.field_bytes_.InitDefault();
160   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
161     _impl_.field_bytes_.Set("", GetArenaForAllocation());
162   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
163   if (from._internal_has_field_bytes()) {
164     _this->_impl_.field_bytes_.Set(from._internal_field_bytes(),
165       _this->GetArenaForAllocation());
166   }
167   ::memcpy(&_impl_.field_uint32_, &from._impl_.field_uint32_,
168     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.field_sint32_) -
169     reinterpret_cast<char*>(&_impl_.field_uint32_)) + sizeof(_impl_.field_sint32_));
170   // @@protoc_insertion_point(copy_constructor:perfetto.protos.TestConfig.DummyFields)
171 }
172 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)173 inline void TestConfig_DummyFields::SharedCtor(
174     ::_pb::Arena* arena, bool is_message_owned) {
175   (void)arena;
176   (void)is_message_owned;
177   new (&_impl_) Impl_{
178       decltype(_impl_._has_bits_){}
179     , /*decltype(_impl_._cached_size_)*/{}
180     , decltype(_impl_.field_string_){}
181     , decltype(_impl_.field_bytes_){}
182     , decltype(_impl_.field_uint32_){0u}
183     , decltype(_impl_.field_int32_){0}
184     , decltype(_impl_.field_uint64_){::uint64_t{0u}}
185     , decltype(_impl_.field_int64_){::int64_t{0}}
186     , decltype(_impl_.field_fixed64_){::uint64_t{0u}}
187     , decltype(_impl_.field_sfixed64_){::int64_t{0}}
188     , decltype(_impl_.field_fixed32_){0u}
189     , decltype(_impl_.field_sfixed32_){0}
190     , decltype(_impl_.field_double_){0}
191     , decltype(_impl_.field_sint64_){::int64_t{0}}
192     , decltype(_impl_.field_float_){0}
193     , decltype(_impl_.field_sint32_){0}
194   };
195   _impl_.field_string_.InitDefault();
196   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
197     _impl_.field_string_.Set("", GetArenaForAllocation());
198   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
199   _impl_.field_bytes_.InitDefault();
200   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
201     _impl_.field_bytes_.Set("", GetArenaForAllocation());
202   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
203 }
204 
~TestConfig_DummyFields()205 TestConfig_DummyFields::~TestConfig_DummyFields() {
206   // @@protoc_insertion_point(destructor:perfetto.protos.TestConfig.DummyFields)
207   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
208   (void)arena;
209     return;
210   }
211   SharedDtor();
212 }
213 
SharedDtor()214 inline void TestConfig_DummyFields::SharedDtor() {
215   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
216   _impl_.field_string_.Destroy();
217   _impl_.field_bytes_.Destroy();
218 }
219 
SetCachedSize(int size) const220 void TestConfig_DummyFields::SetCachedSize(int size) const {
221   _impl_._cached_size_.Set(size);
222 }
223 
Clear()224 void TestConfig_DummyFields::Clear() {
225 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TestConfig.DummyFields)
226   ::uint32_t cached_has_bits = 0;
227   // Prevent compiler warnings about cached_has_bits being unused
228   (void) cached_has_bits;
229 
230   cached_has_bits = _impl_._has_bits_[0];
231   if (cached_has_bits & 0x00000003u) {
232     if (cached_has_bits & 0x00000001u) {
233       _impl_.field_string_.ClearNonDefaultToEmpty();
234     }
235     if (cached_has_bits & 0x00000002u) {
236       _impl_.field_bytes_.ClearNonDefaultToEmpty();
237     }
238   }
239   if (cached_has_bits & 0x000000fcu) {
240     ::memset(&_impl_.field_uint32_, 0, static_cast<size_t>(
241         reinterpret_cast<char*>(&_impl_.field_sfixed64_) -
242         reinterpret_cast<char*>(&_impl_.field_uint32_)) + sizeof(_impl_.field_sfixed64_));
243   }
244   if (cached_has_bits & 0x00003f00u) {
245     ::memset(&_impl_.field_fixed32_, 0, static_cast<size_t>(
246         reinterpret_cast<char*>(&_impl_.field_sint32_) -
247         reinterpret_cast<char*>(&_impl_.field_fixed32_)) + sizeof(_impl_.field_sint32_));
248   }
249   _impl_._has_bits_.Clear();
250   _internal_metadata_.Clear<std::string>();
251 }
252 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)253 const char* TestConfig_DummyFields::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
254 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
255   _Internal::HasBits has_bits{};
256   while (!ctx->Done(&ptr)) {
257     ::uint32_t tag;
258     ptr = ::_pbi::ReadTag(ptr, &tag);
259     switch (tag >> 3) {
260       // optional uint32 field_uint32 = 1;
261       case 1:
262         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
263           _Internal::set_has_field_uint32(&has_bits);
264           _impl_.field_uint32_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
265           CHK_(ptr);
266         } else {
267           goto handle_unusual;
268         }
269         continue;
270       // optional int32 field_int32 = 2;
271       case 2:
272         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
273           _Internal::set_has_field_int32(&has_bits);
274           _impl_.field_int32_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
275           CHK_(ptr);
276         } else {
277           goto handle_unusual;
278         }
279         continue;
280       // optional uint64 field_uint64 = 3;
281       case 3:
282         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
283           _Internal::set_has_field_uint64(&has_bits);
284           _impl_.field_uint64_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
285           CHK_(ptr);
286         } else {
287           goto handle_unusual;
288         }
289         continue;
290       // optional int64 field_int64 = 4;
291       case 4:
292         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
293           _Internal::set_has_field_int64(&has_bits);
294           _impl_.field_int64_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
295           CHK_(ptr);
296         } else {
297           goto handle_unusual;
298         }
299         continue;
300       // optional fixed64 field_fixed64 = 5;
301       case 5:
302         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 41)) {
303           _Internal::set_has_field_fixed64(&has_bits);
304           _impl_.field_fixed64_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint64_t>(ptr);
305           ptr += sizeof(::uint64_t);
306         } else {
307           goto handle_unusual;
308         }
309         continue;
310       // optional sfixed64 field_sfixed64 = 6;
311       case 6:
312         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 49)) {
313           _Internal::set_has_field_sfixed64(&has_bits);
314           _impl_.field_sfixed64_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::int64_t>(ptr);
315           ptr += sizeof(::int64_t);
316         } else {
317           goto handle_unusual;
318         }
319         continue;
320       // optional fixed32 field_fixed32 = 7;
321       case 7:
322         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 61)) {
323           _Internal::set_has_field_fixed32(&has_bits);
324           _impl_.field_fixed32_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::uint32_t>(ptr);
325           ptr += sizeof(::uint32_t);
326         } else {
327           goto handle_unusual;
328         }
329         continue;
330       // optional sfixed32 field_sfixed32 = 8;
331       case 8:
332         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 69)) {
333           _Internal::set_has_field_sfixed32(&has_bits);
334           _impl_.field_sfixed32_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<::int32_t>(ptr);
335           ptr += sizeof(::int32_t);
336         } else {
337           goto handle_unusual;
338         }
339         continue;
340       // optional double field_double = 9;
341       case 9:
342         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 73)) {
343           _Internal::set_has_field_double(&has_bits);
344           _impl_.field_double_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
345           ptr += sizeof(double);
346         } else {
347           goto handle_unusual;
348         }
349         continue;
350       // optional float field_float = 10;
351       case 10:
352         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 85)) {
353           _Internal::set_has_field_float(&has_bits);
354           _impl_.field_float_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
355           ptr += sizeof(float);
356         } else {
357           goto handle_unusual;
358         }
359         continue;
360       // optional sint64 field_sint64 = 11;
361       case 11:
362         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
363           _Internal::set_has_field_sint64(&has_bits);
364           _impl_.field_sint64_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag64(&ptr);
365           CHK_(ptr);
366         } else {
367           goto handle_unusual;
368         }
369         continue;
370       // optional sint32 field_sint32 = 12;
371       case 12:
372         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
373           _Internal::set_has_field_sint32(&has_bits);
374           _impl_.field_sint32_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarintZigZag32(&ptr);
375           CHK_(ptr);
376         } else {
377           goto handle_unusual;
378         }
379         continue;
380       // optional string field_string = 13;
381       case 13:
382         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 106)) {
383           auto str = _internal_mutable_field_string();
384           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
385           CHK_(ptr);
386         } else {
387           goto handle_unusual;
388         }
389         continue;
390       // optional bytes field_bytes = 14;
391       case 14:
392         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 114)) {
393           auto str = _internal_mutable_field_bytes();
394           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
395           CHK_(ptr);
396         } else {
397           goto handle_unusual;
398         }
399         continue;
400       default:
401         goto handle_unusual;
402     }  // switch
403   handle_unusual:
404     if ((tag == 0) || ((tag & 7) == 4)) {
405       CHK_(ptr);
406       ctx->SetLastTag(tag);
407       goto message_done;
408     }
409     ptr = UnknownFieldParse(
410         tag,
411         _internal_metadata_.mutable_unknown_fields<std::string>(),
412         ptr, ctx);
413     CHK_(ptr != nullptr);
414   }  // while
415 message_done:
416   _impl_._has_bits_.Or(has_bits);
417   return ptr;
418 failure:
419   ptr = nullptr;
420   goto message_done;
421 #undef CHK_
422 }
423 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const424 ::uint8_t* TestConfig_DummyFields::_InternalSerialize(
425     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
426   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TestConfig.DummyFields)
427   ::uint32_t cached_has_bits = 0;
428   (void) cached_has_bits;
429 
430   cached_has_bits = _impl_._has_bits_[0];
431   // optional uint32 field_uint32 = 1;
432   if (cached_has_bits & 0x00000004u) {
433     target = stream->EnsureSpace(target);
434     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_field_uint32(), target);
435   }
436 
437   // optional int32 field_int32 = 2;
438   if (cached_has_bits & 0x00000008u) {
439     target = stream->EnsureSpace(target);
440     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_field_int32(), target);
441   }
442 
443   // optional uint64 field_uint64 = 3;
444   if (cached_has_bits & 0x00000010u) {
445     target = stream->EnsureSpace(target);
446     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_field_uint64(), target);
447   }
448 
449   // optional int64 field_int64 = 4;
450   if (cached_has_bits & 0x00000020u) {
451     target = stream->EnsureSpace(target);
452     target = ::_pbi::WireFormatLite::WriteInt64ToArray(4, this->_internal_field_int64(), target);
453   }
454 
455   // optional fixed64 field_fixed64 = 5;
456   if (cached_has_bits & 0x00000040u) {
457     target = stream->EnsureSpace(target);
458     target = ::_pbi::WireFormatLite::WriteFixed64ToArray(5, this->_internal_field_fixed64(), target);
459   }
460 
461   // optional sfixed64 field_sfixed64 = 6;
462   if (cached_has_bits & 0x00000080u) {
463     target = stream->EnsureSpace(target);
464     target = ::_pbi::WireFormatLite::WriteSFixed64ToArray(6, this->_internal_field_sfixed64(), target);
465   }
466 
467   // optional fixed32 field_fixed32 = 7;
468   if (cached_has_bits & 0x00000100u) {
469     target = stream->EnsureSpace(target);
470     target = ::_pbi::WireFormatLite::WriteFixed32ToArray(7, this->_internal_field_fixed32(), target);
471   }
472 
473   // optional sfixed32 field_sfixed32 = 8;
474   if (cached_has_bits & 0x00000200u) {
475     target = stream->EnsureSpace(target);
476     target = ::_pbi::WireFormatLite::WriteSFixed32ToArray(8, this->_internal_field_sfixed32(), target);
477   }
478 
479   // optional double field_double = 9;
480   if (cached_has_bits & 0x00000400u) {
481     target = stream->EnsureSpace(target);
482     target = ::_pbi::WireFormatLite::WriteDoubleToArray(9, this->_internal_field_double(), target);
483   }
484 
485   // optional float field_float = 10;
486   if (cached_has_bits & 0x00001000u) {
487     target = stream->EnsureSpace(target);
488     target = ::_pbi::WireFormatLite::WriteFloatToArray(10, this->_internal_field_float(), target);
489   }
490 
491   // optional sint64 field_sint64 = 11;
492   if (cached_has_bits & 0x00000800u) {
493     target = stream->EnsureSpace(target);
494     target = ::_pbi::WireFormatLite::WriteSInt64ToArray(11, this->_internal_field_sint64(), target);
495   }
496 
497   // optional sint32 field_sint32 = 12;
498   if (cached_has_bits & 0x00002000u) {
499     target = stream->EnsureSpace(target);
500     target = ::_pbi::WireFormatLite::WriteSInt32ToArray(12, this->_internal_field_sint32(), target);
501   }
502 
503   // optional string field_string = 13;
504   if (cached_has_bits & 0x00000001u) {
505     target = stream->WriteStringMaybeAliased(
506         13, this->_internal_field_string(), target);
507   }
508 
509   // optional bytes field_bytes = 14;
510   if (cached_has_bits & 0x00000002u) {
511     target = stream->WriteBytesMaybeAliased(
512         14, this->_internal_field_bytes(), target);
513   }
514 
515   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
516     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
517         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
518   }
519   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TestConfig.DummyFields)
520   return target;
521 }
522 
ByteSizeLong() const523 size_t TestConfig_DummyFields::ByteSizeLong() const {
524 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TestConfig.DummyFields)
525   size_t total_size = 0;
526 
527   ::uint32_t cached_has_bits = 0;
528   // Prevent compiler warnings about cached_has_bits being unused
529   (void) cached_has_bits;
530 
531   cached_has_bits = _impl_._has_bits_[0];
532   if (cached_has_bits & 0x000000ffu) {
533     // optional string field_string = 13;
534     if (cached_has_bits & 0x00000001u) {
535       total_size += 1 +
536         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
537           this->_internal_field_string());
538     }
539 
540     // optional bytes field_bytes = 14;
541     if (cached_has_bits & 0x00000002u) {
542       total_size += 1 +
543         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
544           this->_internal_field_bytes());
545     }
546 
547     // optional uint32 field_uint32 = 1;
548     if (cached_has_bits & 0x00000004u) {
549       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_field_uint32());
550     }
551 
552     // optional int32 field_int32 = 2;
553     if (cached_has_bits & 0x00000008u) {
554       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_field_int32());
555     }
556 
557     // optional uint64 field_uint64 = 3;
558     if (cached_has_bits & 0x00000010u) {
559       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_field_uint64());
560     }
561 
562     // optional int64 field_int64 = 4;
563     if (cached_has_bits & 0x00000020u) {
564       total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_field_int64());
565     }
566 
567     // optional fixed64 field_fixed64 = 5;
568     if (cached_has_bits & 0x00000040u) {
569       total_size += 1 + 8;
570     }
571 
572     // optional sfixed64 field_sfixed64 = 6;
573     if (cached_has_bits & 0x00000080u) {
574       total_size += 1 + 8;
575     }
576 
577   }
578   if (cached_has_bits & 0x00003f00u) {
579     // optional fixed32 field_fixed32 = 7;
580     if (cached_has_bits & 0x00000100u) {
581       total_size += 1 + 4;
582     }
583 
584     // optional sfixed32 field_sfixed32 = 8;
585     if (cached_has_bits & 0x00000200u) {
586       total_size += 1 + 4;
587     }
588 
589     // optional double field_double = 9;
590     if (cached_has_bits & 0x00000400u) {
591       total_size += 1 + 8;
592     }
593 
594     // optional sint64 field_sint64 = 11;
595     if (cached_has_bits & 0x00000800u) {
596       total_size += ::_pbi::WireFormatLite::SInt64SizePlusOne(this->_internal_field_sint64());
597     }
598 
599     // optional float field_float = 10;
600     if (cached_has_bits & 0x00001000u) {
601       total_size += 1 + 4;
602     }
603 
604     // optional sint32 field_sint32 = 12;
605     if (cached_has_bits & 0x00002000u) {
606       total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne(this->_internal_field_sint32());
607     }
608 
609   }
610   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
611     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
612   }
613   int cached_size = ::_pbi::ToCachedSize(total_size);
614   SetCachedSize(cached_size);
615   return total_size;
616 }
617 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)618 void TestConfig_DummyFields::CheckTypeAndMergeFrom(
619     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
620   MergeFrom(*::_pbi::DownCast<const TestConfig_DummyFields*>(
621       &from));
622 }
623 
MergeFrom(const TestConfig_DummyFields & from)624 void TestConfig_DummyFields::MergeFrom(const TestConfig_DummyFields& from) {
625   TestConfig_DummyFields* const _this = this;
626   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TestConfig.DummyFields)
627   GOOGLE_DCHECK_NE(&from, _this);
628   ::uint32_t cached_has_bits = 0;
629   (void) cached_has_bits;
630 
631   cached_has_bits = from._impl_._has_bits_[0];
632   if (cached_has_bits & 0x000000ffu) {
633     if (cached_has_bits & 0x00000001u) {
634       _this->_internal_set_field_string(from._internal_field_string());
635     }
636     if (cached_has_bits & 0x00000002u) {
637       _this->_internal_set_field_bytes(from._internal_field_bytes());
638     }
639     if (cached_has_bits & 0x00000004u) {
640       _this->_impl_.field_uint32_ = from._impl_.field_uint32_;
641     }
642     if (cached_has_bits & 0x00000008u) {
643       _this->_impl_.field_int32_ = from._impl_.field_int32_;
644     }
645     if (cached_has_bits & 0x00000010u) {
646       _this->_impl_.field_uint64_ = from._impl_.field_uint64_;
647     }
648     if (cached_has_bits & 0x00000020u) {
649       _this->_impl_.field_int64_ = from._impl_.field_int64_;
650     }
651     if (cached_has_bits & 0x00000040u) {
652       _this->_impl_.field_fixed64_ = from._impl_.field_fixed64_;
653     }
654     if (cached_has_bits & 0x00000080u) {
655       _this->_impl_.field_sfixed64_ = from._impl_.field_sfixed64_;
656     }
657     _this->_impl_._has_bits_[0] |= cached_has_bits;
658   }
659   if (cached_has_bits & 0x00003f00u) {
660     if (cached_has_bits & 0x00000100u) {
661       _this->_impl_.field_fixed32_ = from._impl_.field_fixed32_;
662     }
663     if (cached_has_bits & 0x00000200u) {
664       _this->_impl_.field_sfixed32_ = from._impl_.field_sfixed32_;
665     }
666     if (cached_has_bits & 0x00000400u) {
667       _this->_impl_.field_double_ = from._impl_.field_double_;
668     }
669     if (cached_has_bits & 0x00000800u) {
670       _this->_impl_.field_sint64_ = from._impl_.field_sint64_;
671     }
672     if (cached_has_bits & 0x00001000u) {
673       _this->_impl_.field_float_ = from._impl_.field_float_;
674     }
675     if (cached_has_bits & 0x00002000u) {
676       _this->_impl_.field_sint32_ = from._impl_.field_sint32_;
677     }
678     _this->_impl_._has_bits_[0] |= cached_has_bits;
679   }
680   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
681 }
682 
CopyFrom(const TestConfig_DummyFields & from)683 void TestConfig_DummyFields::CopyFrom(const TestConfig_DummyFields& from) {
684 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TestConfig.DummyFields)
685   if (&from == this) return;
686   Clear();
687   MergeFrom(from);
688 }
689 
IsInitialized() const690 bool TestConfig_DummyFields::IsInitialized() const {
691   return true;
692 }
693 
InternalSwap(TestConfig_DummyFields * other)694 void TestConfig_DummyFields::InternalSwap(TestConfig_DummyFields* other) {
695   using std::swap;
696   auto* lhs_arena = GetArenaForAllocation();
697   auto* rhs_arena = other->GetArenaForAllocation();
698   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
699   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
700   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
701       &_impl_.field_string_, lhs_arena,
702       &other->_impl_.field_string_, rhs_arena
703   );
704   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
705       &_impl_.field_bytes_, lhs_arena,
706       &other->_impl_.field_bytes_, rhs_arena
707   );
708   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
709       PROTOBUF_FIELD_OFFSET(TestConfig_DummyFields, _impl_.field_sint32_)
710       + sizeof(TestConfig_DummyFields::_impl_.field_sint32_)  // NOLINT
711       - PROTOBUF_FIELD_OFFSET(TestConfig_DummyFields, _impl_.field_uint32_)>(
712           reinterpret_cast<char*>(&_impl_.field_uint32_),
713           reinterpret_cast<char*>(&other->_impl_.field_uint32_));
714 }
715 
GetTypeName() const716 std::string TestConfig_DummyFields::GetTypeName() const {
717   return "perfetto.protos.TestConfig.DummyFields";
718 }
719 
720 
721 // ===================================================================
722 
723 class TestConfig::_Internal {
724  public:
725   using HasBits = decltype(std::declval<TestConfig>()._impl_._has_bits_);
set_has_message_count(HasBits * has_bits)726   static void set_has_message_count(HasBits* has_bits) {
727     (*has_bits)[0] |= 2u;
728   }
set_has_max_messages_per_second(HasBits * has_bits)729   static void set_has_max_messages_per_second(HasBits* has_bits) {
730     (*has_bits)[0] |= 4u;
731   }
set_has_seed(HasBits * has_bits)732   static void set_has_seed(HasBits* has_bits) {
733     (*has_bits)[0] |= 8u;
734   }
set_has_message_size(HasBits * has_bits)735   static void set_has_message_size(HasBits* has_bits) {
736     (*has_bits)[0] |= 16u;
737   }
set_has_send_batch_on_register(HasBits * has_bits)738   static void set_has_send_batch_on_register(HasBits* has_bits) {
739     (*has_bits)[0] |= 32u;
740   }
741   static const ::perfetto::protos::TestConfig_DummyFields& dummy_fields(const TestConfig* msg);
set_has_dummy_fields(HasBits * has_bits)742   static void set_has_dummy_fields(HasBits* has_bits) {
743     (*has_bits)[0] |= 1u;
744   }
745 };
746 
747 const ::perfetto::protos::TestConfig_DummyFields&
dummy_fields(const TestConfig * msg)748 TestConfig::_Internal::dummy_fields(const TestConfig* msg) {
749   return *msg->_impl_.dummy_fields_;
750 }
TestConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)751 TestConfig::TestConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
752                          bool is_message_owned)
753   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
754   SharedCtor(arena, is_message_owned);
755   // @@protoc_insertion_point(arena_constructor:perfetto.protos.TestConfig)
756 }
TestConfig(const TestConfig & from)757 TestConfig::TestConfig(const TestConfig& from)
758   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
759   TestConfig* const _this = this; (void)_this;
760   new (&_impl_) Impl_{
761       decltype(_impl_._has_bits_){from._impl_._has_bits_}
762     , /*decltype(_impl_._cached_size_)*/{}
763     , decltype(_impl_.dummy_fields_){nullptr}
764     , decltype(_impl_.message_count_){}
765     , decltype(_impl_.max_messages_per_second_){}
766     , decltype(_impl_.seed_){}
767     , decltype(_impl_.message_size_){}
768     , decltype(_impl_.send_batch_on_register_){}};
769 
770   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
771   if (from._internal_has_dummy_fields()) {
772     _this->_impl_.dummy_fields_ = new ::perfetto::protos::TestConfig_DummyFields(*from._impl_.dummy_fields_);
773   }
774   ::memcpy(&_impl_.message_count_, &from._impl_.message_count_,
775     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.send_batch_on_register_) -
776     reinterpret_cast<char*>(&_impl_.message_count_)) + sizeof(_impl_.send_batch_on_register_));
777   // @@protoc_insertion_point(copy_constructor:perfetto.protos.TestConfig)
778 }
779 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)780 inline void TestConfig::SharedCtor(
781     ::_pb::Arena* arena, bool is_message_owned) {
782   (void)arena;
783   (void)is_message_owned;
784   new (&_impl_) Impl_{
785       decltype(_impl_._has_bits_){}
786     , /*decltype(_impl_._cached_size_)*/{}
787     , decltype(_impl_.dummy_fields_){nullptr}
788     , decltype(_impl_.message_count_){0u}
789     , decltype(_impl_.max_messages_per_second_){0u}
790     , decltype(_impl_.seed_){0u}
791     , decltype(_impl_.message_size_){0u}
792     , decltype(_impl_.send_batch_on_register_){false}
793   };
794 }
795 
~TestConfig()796 TestConfig::~TestConfig() {
797   // @@protoc_insertion_point(destructor:perfetto.protos.TestConfig)
798   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
799   (void)arena;
800     return;
801   }
802   SharedDtor();
803 }
804 
SharedDtor()805 inline void TestConfig::SharedDtor() {
806   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
807   if (this != internal_default_instance()) delete _impl_.dummy_fields_;
808 }
809 
SetCachedSize(int size) const810 void TestConfig::SetCachedSize(int size) const {
811   _impl_._cached_size_.Set(size);
812 }
813 
Clear()814 void TestConfig::Clear() {
815 // @@protoc_insertion_point(message_clear_start:perfetto.protos.TestConfig)
816   ::uint32_t cached_has_bits = 0;
817   // Prevent compiler warnings about cached_has_bits being unused
818   (void) cached_has_bits;
819 
820   cached_has_bits = _impl_._has_bits_[0];
821   if (cached_has_bits & 0x00000001u) {
822     GOOGLE_DCHECK(_impl_.dummy_fields_ != nullptr);
823     _impl_.dummy_fields_->Clear();
824   }
825   if (cached_has_bits & 0x0000003eu) {
826     ::memset(&_impl_.message_count_, 0, static_cast<size_t>(
827         reinterpret_cast<char*>(&_impl_.send_batch_on_register_) -
828         reinterpret_cast<char*>(&_impl_.message_count_)) + sizeof(_impl_.send_batch_on_register_));
829   }
830   _impl_._has_bits_.Clear();
831   _internal_metadata_.Clear<std::string>();
832 }
833 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)834 const char* TestConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
835 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
836   _Internal::HasBits has_bits{};
837   while (!ctx->Done(&ptr)) {
838     ::uint32_t tag;
839     ptr = ::_pbi::ReadTag(ptr, &tag);
840     switch (tag >> 3) {
841       // optional uint32 message_count = 1;
842       case 1:
843         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
844           _Internal::set_has_message_count(&has_bits);
845           _impl_.message_count_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
846           CHK_(ptr);
847         } else {
848           goto handle_unusual;
849         }
850         continue;
851       // optional uint32 max_messages_per_second = 2;
852       case 2:
853         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
854           _Internal::set_has_max_messages_per_second(&has_bits);
855           _impl_.max_messages_per_second_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
856           CHK_(ptr);
857         } else {
858           goto handle_unusual;
859         }
860         continue;
861       // optional uint32 seed = 3;
862       case 3:
863         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
864           _Internal::set_has_seed(&has_bits);
865           _impl_.seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
866           CHK_(ptr);
867         } else {
868           goto handle_unusual;
869         }
870         continue;
871       // optional uint32 message_size = 4;
872       case 4:
873         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
874           _Internal::set_has_message_size(&has_bits);
875           _impl_.message_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
876           CHK_(ptr);
877         } else {
878           goto handle_unusual;
879         }
880         continue;
881       // optional bool send_batch_on_register = 5;
882       case 5:
883         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
884           _Internal::set_has_send_batch_on_register(&has_bits);
885           _impl_.send_batch_on_register_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
886           CHK_(ptr);
887         } else {
888           goto handle_unusual;
889         }
890         continue;
891       // optional .perfetto.protos.TestConfig.DummyFields dummy_fields = 6;
892       case 6:
893         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 50)) {
894           ptr = ctx->ParseMessage(_internal_mutable_dummy_fields(), ptr);
895           CHK_(ptr);
896         } else {
897           goto handle_unusual;
898         }
899         continue;
900       default:
901         goto handle_unusual;
902     }  // switch
903   handle_unusual:
904     if ((tag == 0) || ((tag & 7) == 4)) {
905       CHK_(ptr);
906       ctx->SetLastTag(tag);
907       goto message_done;
908     }
909     ptr = UnknownFieldParse(
910         tag,
911         _internal_metadata_.mutable_unknown_fields<std::string>(),
912         ptr, ctx);
913     CHK_(ptr != nullptr);
914   }  // while
915 message_done:
916   _impl_._has_bits_.Or(has_bits);
917   return ptr;
918 failure:
919   ptr = nullptr;
920   goto message_done;
921 #undef CHK_
922 }
923 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const924 ::uint8_t* TestConfig::_InternalSerialize(
925     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
926   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.TestConfig)
927   ::uint32_t cached_has_bits = 0;
928   (void) cached_has_bits;
929 
930   cached_has_bits = _impl_._has_bits_[0];
931   // optional uint32 message_count = 1;
932   if (cached_has_bits & 0x00000002u) {
933     target = stream->EnsureSpace(target);
934     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_message_count(), target);
935   }
936 
937   // optional uint32 max_messages_per_second = 2;
938   if (cached_has_bits & 0x00000004u) {
939     target = stream->EnsureSpace(target);
940     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_max_messages_per_second(), target);
941   }
942 
943   // optional uint32 seed = 3;
944   if (cached_has_bits & 0x00000008u) {
945     target = stream->EnsureSpace(target);
946     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_seed(), target);
947   }
948 
949   // optional uint32 message_size = 4;
950   if (cached_has_bits & 0x00000010u) {
951     target = stream->EnsureSpace(target);
952     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_message_size(), target);
953   }
954 
955   // optional bool send_batch_on_register = 5;
956   if (cached_has_bits & 0x00000020u) {
957     target = stream->EnsureSpace(target);
958     target = ::_pbi::WireFormatLite::WriteBoolToArray(5, this->_internal_send_batch_on_register(), target);
959   }
960 
961   // optional .perfetto.protos.TestConfig.DummyFields dummy_fields = 6;
962   if (cached_has_bits & 0x00000001u) {
963     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
964       InternalWriteMessage(6, _Internal::dummy_fields(this),
965         _Internal::dummy_fields(this).GetCachedSize(), target, stream);
966   }
967 
968   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
969     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
970         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
971   }
972   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.TestConfig)
973   return target;
974 }
975 
ByteSizeLong() const976 size_t TestConfig::ByteSizeLong() const {
977 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.TestConfig)
978   size_t total_size = 0;
979 
980   ::uint32_t cached_has_bits = 0;
981   // Prevent compiler warnings about cached_has_bits being unused
982   (void) cached_has_bits;
983 
984   cached_has_bits = _impl_._has_bits_[0];
985   if (cached_has_bits & 0x0000003fu) {
986     // optional .perfetto.protos.TestConfig.DummyFields dummy_fields = 6;
987     if (cached_has_bits & 0x00000001u) {
988       total_size += 1 +
989         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
990           *_impl_.dummy_fields_);
991     }
992 
993     // optional uint32 message_count = 1;
994     if (cached_has_bits & 0x00000002u) {
995       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_message_count());
996     }
997 
998     // optional uint32 max_messages_per_second = 2;
999     if (cached_has_bits & 0x00000004u) {
1000       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_max_messages_per_second());
1001     }
1002 
1003     // optional uint32 seed = 3;
1004     if (cached_has_bits & 0x00000008u) {
1005       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_seed());
1006     }
1007 
1008     // optional uint32 message_size = 4;
1009     if (cached_has_bits & 0x00000010u) {
1010       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_message_size());
1011     }
1012 
1013     // optional bool send_batch_on_register = 5;
1014     if (cached_has_bits & 0x00000020u) {
1015       total_size += 1 + 1;
1016     }
1017 
1018   }
1019   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1020     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1021   }
1022   int cached_size = ::_pbi::ToCachedSize(total_size);
1023   SetCachedSize(cached_size);
1024   return total_size;
1025 }
1026 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1027 void TestConfig::CheckTypeAndMergeFrom(
1028     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1029   MergeFrom(*::_pbi::DownCast<const TestConfig*>(
1030       &from));
1031 }
1032 
MergeFrom(const TestConfig & from)1033 void TestConfig::MergeFrom(const TestConfig& from) {
1034   TestConfig* const _this = this;
1035   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.TestConfig)
1036   GOOGLE_DCHECK_NE(&from, _this);
1037   ::uint32_t cached_has_bits = 0;
1038   (void) cached_has_bits;
1039 
1040   cached_has_bits = from._impl_._has_bits_[0];
1041   if (cached_has_bits & 0x0000003fu) {
1042     if (cached_has_bits & 0x00000001u) {
1043       _this->_internal_mutable_dummy_fields()->::perfetto::protos::TestConfig_DummyFields::MergeFrom(
1044           from._internal_dummy_fields());
1045     }
1046     if (cached_has_bits & 0x00000002u) {
1047       _this->_impl_.message_count_ = from._impl_.message_count_;
1048     }
1049     if (cached_has_bits & 0x00000004u) {
1050       _this->_impl_.max_messages_per_second_ = from._impl_.max_messages_per_second_;
1051     }
1052     if (cached_has_bits & 0x00000008u) {
1053       _this->_impl_.seed_ = from._impl_.seed_;
1054     }
1055     if (cached_has_bits & 0x00000010u) {
1056       _this->_impl_.message_size_ = from._impl_.message_size_;
1057     }
1058     if (cached_has_bits & 0x00000020u) {
1059       _this->_impl_.send_batch_on_register_ = from._impl_.send_batch_on_register_;
1060     }
1061     _this->_impl_._has_bits_[0] |= cached_has_bits;
1062   }
1063   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1064 }
1065 
CopyFrom(const TestConfig & from)1066 void TestConfig::CopyFrom(const TestConfig& from) {
1067 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.TestConfig)
1068   if (&from == this) return;
1069   Clear();
1070   MergeFrom(from);
1071 }
1072 
IsInitialized() const1073 bool TestConfig::IsInitialized() const {
1074   return true;
1075 }
1076 
InternalSwap(TestConfig * other)1077 void TestConfig::InternalSwap(TestConfig* other) {
1078   using std::swap;
1079   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1080   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1081   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1082       PROTOBUF_FIELD_OFFSET(TestConfig, _impl_.send_batch_on_register_)
1083       + sizeof(TestConfig::_impl_.send_batch_on_register_)  // NOLINT
1084       - PROTOBUF_FIELD_OFFSET(TestConfig, _impl_.dummy_fields_)>(
1085           reinterpret_cast<char*>(&_impl_.dummy_fields_),
1086           reinterpret_cast<char*>(&other->_impl_.dummy_fields_));
1087 }
1088 
GetTypeName() const1089 std::string TestConfig::GetTypeName() const {
1090   return "perfetto.protos.TestConfig";
1091 }
1092 
1093 
1094 // @@protoc_insertion_point(namespace_scope)
1095 }  // namespace protos
1096 }  // namespace perfetto
1097 PROTOBUF_NAMESPACE_OPEN
1098 template<> PROTOBUF_NOINLINE ::perfetto::protos::TestConfig_DummyFields*
CreateMaybeMessage(Arena * arena)1099 Arena::CreateMaybeMessage< ::perfetto::protos::TestConfig_DummyFields >(Arena* arena) {
1100   return Arena::CreateMessageInternal< ::perfetto::protos::TestConfig_DummyFields >(arena);
1101 }
1102 template<> PROTOBUF_NOINLINE ::perfetto::protos::TestConfig*
CreateMaybeMessage(Arena * arena)1103 Arena::CreateMaybeMessage< ::perfetto::protos::TestConfig >(Arena* arena) {
1104   return Arena::CreateMessageInternal< ::perfetto::protos::TestConfig >(arena);
1105 }
1106 PROTOBUF_NAMESPACE_CLOSE
1107 
1108 // @@protoc_insertion_point(global_scope)
1109 #include <google/protobuf/port_undef.inc>
1110